Alphabeta Math
LemmaStatement: Literature-sourcedProof: AI-adaptedPipeline-generatedjudge pass (gpt-6-luna)
How statement and proof provenance work

The first chip identifies the source of the statement or construction; the second identifies the source of its local proof or verification.

  • Literature-sourced: the exact statement appears in a cited source; only wording and notation differ.
  • AI-adapted: a semantically identical restatement of literature-sourced material, modulo indexing, notation, and boundary cases adopted by the library.
  • AI-generated: a genuinely novel statement formulated by AI, with no source for the claim itself.

These labels describe origin, not correctness: citations and verification chips remain separate evidence.

Logspace uniform iterated multiplication threshold circuits

Statement

For m,w≥1, let the input be an explicit array of m nonnegative w-bit integers, with tuple-addressed bits xi,j and fixed dimensions supplied to the uniformity machine. Power-of-two padding of the array dimensions is permitted, with padded entries zero. Their exact product, zero-padded to mw bits, is computed by constant-depth polynomial-size circuits over AND, OR, NOT and MAJ. Circuit descriptions and gate-predecessor predicates are computable in logarithmic space in the total input length. This item does not assert DLOGTIME-uniform multiplication, and its encoding convention does not include arbitrary effectively decodable encodings.

Facts & Assumptions

Given: m,w≥1 and the input representation in the Statement. Put N=mw. A short integer has O(log⁡(N+2)) bits, and a long word has NO(1) bits. All prime lists and their subsets below depend only on circuit dimensions, not input values.

[F1]

Prime number theorem gives π(x)∼x/log⁡x, and hence π(x)≥x/(2log⁡x) for all sufficiently large x.

[F2]

Every prime modulus admits a primitive root (Every prime modulus admits a primitive root), that is, a generator of its nonzero residue group.

[F3]

Exact sums of explicitly listed nonnegative binary integers have constant-depth polynomial-size DLOGTIME-uniform threshold circuits under the tuple-addressed array convention (DLOGTIME uniform iterated addition threshold circuits).

Proof

1.1F3givenconstruct

A function of a fixed number of short arguments has polynomially many argument tuples. If its table is logspace-computable, realize each output bit by an OR of equality conjunctions over the tuples yielding one. This is a constant-depth polynomial-size logspace-uniform Boolean lookup circuit. Short addition, multiplication, reduction, inverses modulo a prime, and the table (a,e,p)↦ae mod p have this property. For the power table, use repeated squaring with a constant number of short residues and a short exponent counter; short multiplication uses grade-school arithmetic in logarithmic space. Find an inverse by trying every short candidate, and test primality by trial division. Enumerate the j-th prime by a counter and these primality tests whenever j and that prime are polynomially bounded. We may also add polynomially many polynomial-width words by [F3], whose uniformity is stronger than required here.

2.1F2F3step 1.1constructalgebra

For a fixed short prime p>2, [F2] gives a generator g of the nonzero residues. Find the least such g by testing all candidates and all exponents below p−1 with step 1.1. The tables a↦ℓ(a), where gℓ(a)≡a(modp) and 0≤ℓ(a)<p−1, and (g,e,p)↦ge mod p are logspace-computable by enumeration and modular powering with a constant number of short counters. For nonzero inputs a1,…,ad with polynomially bounded d, their product modulo p is g∑iℓ(ai) mod p. The exponent sum is polynomially bounded, so compute it with [F3] and use a short power lookup. If any input is zero, select zero instead. For p=2, the product is one exactly when all inputs are one. This gives iterated multiplication in any fixed polynomial-size residue basis in logspace-uniform constant depth. It uses only short tables and addition, without assuming binary iterated multiplication.

2.2F3step 1.1constructalgebra

Convert a long word X=∑jxj2j to residues by computing xj(2j mod p) for each bit position and modulus, summing these short contributions with [F3], and reducing the result modulo p by step 1.1. The sum is polynomially bounded in N, because its number of contributions and p are. Each constant 2j mod p is logspace-computable. Thus binary-to-residue conversion has the required circuit bounds; for X outside the basis range, its vector represents its remainder in that range.

2.3step 1.1constructalgebra

Fix a basis T=∏i=1kpi of distinct short primes. Set Ci=T/pi and hi=(Ci mod pi)−1 mod pi. The binary words T,Ci need not be computed: their required short residues, and then hi, are generated in logspace by scanning factors and multiplying modulo pi. Since Cihi is one modulo pi and zero modulo all other basis primes, for the residue vector (xi) of 0≤X<T we have ∑ixihiCi=X+rT,S:=∑ixihipi=r+XT for a nonnegative integer r. Indeed a difference divisible by each of the distinct primes is divisible by their product, while two representatives in [0,T) cannot differ by a nonzero multiple of T. Existence of a representative for every residue vector follows by taking the remainder modulo T of the displayed nonnegative sum.

3.1F3step 1.1step 2.3constructalgebra

We give a comparison circuit with controlled rounding. Let U bound the primes of the fixed basis, put L=k⌈log⁡2U⌉, so T≤2L, and choose t=L+⌈log⁡2k⌉+4. Compute Fi=⌊xihi2t/pi⌋ and Z=∑iFi+k2t,S≤Z≤S+ε,ε=k2−t<14T. Because X/T is a multiple of 1/T in [0,1), ⌊Z⌋=r, including X=0 and X=T−1. The low t bits of ∑iFi+k therefore represent a dyadic fraction fX satisfying X/T≤fX≤X/T+ε. Hence X<Y if and only if fX<fY: distinct representatives differ by at least 1/T, and equal representatives give identical residue vectors and identical fractions. All bits of Fi have the required circuits. Its integer part ⌊xihi/pi⌋ is a short lookup. For odd pi, bit j≥1 after the binary point of xihi/pi equals (xihi2j mod pi) mod 2: write xihi2j=api+b; its even left side and odd pi imply that a,b have the same parity. These residues are short lookups using modular-power constants. For pi=2, only the first fractional bit can be nonzero. This computes precisely the truncation defining Fi. Sum with [F3] and compare the t-bit fractions by an OR over their highest differing position, with equality required at all higher positions. That comparator is constant-depth Boolean. Thus residue comparison is logspace-uniform constant depth. The upward offset is essential to handle an exact integer S correctly.

3.2F1step 1.1step 2.3constructalgebra

Put k=N+5 and let M be the product of the first k primes, including 2. Then M≥2k>2N+4. For each output index 1≤s<N, take s disjoint blocks of k consecutive primes beyond those first k primes, and let Ai be the product of block i. Every Ai is odd and exceeds M, since each of its factors exceeds the corresponding factor of M. The Ai are pairwise relatively prime and relatively prime to M. Only O(N2) primes are needed. By [F1], their numerical values are polynomially bounded in N for all sufficiently large N; the finitely many smaller dimensions have fixed circuits. Enumeration of each block and its residues modulo any short prime is logspace-computable by scanning its factors as in step 1.1 and step 2.3. No bit of a long prime product is requested from the uniformity machine.

4.1step 1.1step 2.3step 3.1constructalgebra

Extend the representation of X∈[0,T) to a fixed short prime q not in its basis by trying every possible residue a∈[0,q). In basis Tq, each candidate has a unique representative Xa. The representatives with the old residues are exactly X+jT, 0≤j<q, so exactly one is below T. The representation of T in basis Tq has zero on the old primes and the fixed short product T mod q on the new prime. Compare each candidate with it using step 3.1 and select the unique successful a. This computes X mod q. Extend to any polynomial-size new basis in parallel, treating its new primes independently. Removing primes just discards coordinates. No binary value of T is needed.

5.1step 1.1step 2.3step 4.1constructalgebra

Fix a squarefree divisor B of the basis product T and put P=T/B. Restrict the representation of X∈[0,T) to basis B to obtain R=X mod B in [0,B), and extend R back to basis T by step 4.1. For each p∣P, compute (X−R)B−1 mod p, where B mod p and its inverse are fixed short constants from step 1.1. This is the representation of Q=⌊X/B⌋ modulo P; since 0≤Q<P, it is the canonical one. Extend it from basis P to basis T by step 4.1. If P=1, output zero; if B=1, return X. All componentwise operations are short lookups. This proves constant-depth logspace-uniform division by these fixed squarefree products without assuming general binary division.

6.1step 1.1step 2.1step 4.1step 5.1step 3.2constructalgebra

Let X∈[0,M) be given in basis M and fix 1≤s<N. Put A=∏i=1sAi and P=MA. Extend X to basis P by step 4.1. Compute each fixed Ai modulo each basis prime and add one componentwise. This represents Ai+1<P. Since 2∣P and Ai is odd, step 5.1 computes Hi=(Ai+1)/2 in basis P. Using step 2.1, compute Y=X∏iHi in that basis. There is no wraparound, since Hi<Ai and X<M imply Y<P. Divide by A with step 5.1 to obtain Q=⌊Y/A⌋ in basis P.

7.1step 1.1step 3.1step 3.2step 6.1constructalgebra

We have Y/A=(X/2s)∏i(1+1/Ai). Since Ai>M and M>2N+4>s(s+1), the binomial coefficients bounded by powers of s give ∏i(1+1/Ai)<(1+1/M)s≤∑j≥0(s/M)j=1+sM−s<1+s+1M. Consequently 0≤Y/A−X/2s<(s+1)/2s≤1. Thus Q is either ⌊X/2s⌋ or that integer plus one. Retain Q unless Q2s>X, in which case subtract one. The comparison in basis P is valid without wraparound: Q2s<X+2s<M+2N<2M<P. Compute the residues of 2s by step 1.1, multiply componentwise, and compare by step 3.1. Subtraction by one is componentwise and occurs only when Q≥1. The selected vector represents ⌊X/2s⌋, whose residue modulo 2 is bit s of X. Bit zero is already the residue of X modulo 2. Thus all N bits are recovered by parallel copies of a constant-depth circuit.

8.1step 2.1step 2.2step 3.2step 6.1step 7.1constructalgebra

Convert the m input words to basis M by step 2.2 and multiply their residue vectors by step 2.1. Their exact product Z satisfies 0≤Z<2mw=2N<M, including zero factors, so this is its canonical residue vector. Apply step 3.2 and step 6.1 and step 7.1 in parallel at every index s<N. The result is its exact binary product, with precisely mw output bits and leading zeros where required.

9.1F3step 1.1step 2.1step 2.2step 2.3step 3.1step 4.1step 5.1step 3.2step 6.1step 7.1step 8.1construct∎

Every basis length, prime value, table argument, loop index and word width above is polynomially bounded in N. In step 3.1, the approximant width is O(k′log⁡U) for its polynomial-size basis length k′, hence polynomial as well. Each table has a fixed number of short arguments and polynomially many rows. Each conversion, comparison, extension and division uses a fixed finite number of layers of tables, Boolean gates and [F3]; their nesting in step 1.1 and step 2.1 and step 2.2 and step 2.3 and step 3.1 and step 4.1 and step 5.1 and step 3.2 and step 6.1 and step 7.1 and step 8.1 has depth independent of all dimensions and prime counts. Trials over primes, residues, table rows and output bits are parallel copies. Thus the total size is polynomial and depth constant. Label gates by their stage and a fixed number of polynomially bounded coordinates. A logspace machine enumerates the fixed prime lists, computes needed residues by repeated modular multiplication, computes power and discrete-log table bits as in step 1.1 and step 2.1, and decides local wiring using short counters. The composition depth of subcircuit descriptions is fixed, so intermediate descriptions can be recomputed using O(log⁡(N+2)) workspace. The machine never stores M,P,Ai or another long product. The addition circuits from [F3] are also logspace-uniform. This proves both logarithmic-space description generation and the gate-predecessor predicate, completing the Statement.

Depends on

Used by

Dependency tree · two levels

9 results within two dependency steps of this one, each drawn at its shortest distance from it. An arrow runs from a result to what uses it, so the chart reads left to right and ends at this result, which carries a heavier outline. Every node is a link to that result. Click elsewhere on the chart to enlarge it.

Sources