The perfect cuboid problem asks whether there exists a rectangular box whose three edge
lengths, three face diagonals, and space diagonal are all integers. Although many Euler bricks are known, no perfect cuboid has been discovered, and no impossibility proof is known. This manuscript reports a computational investigation of a branch-switch obstruction phe- nomenon among primitive Euler bricks. For a primitive Euler brick A = (a, b, c), define the obstruction quantity SA = a 2 + b 2 + c 2 . Primes appearing to odd exponent in the factorization of SA are called obstruction primes. The investigation focused on special pairs of primitive Euler bricks related by rational scaling ratios. A large-scale computation through a search bound of 1.01 × 109 produced 1,968 prim- itive Euler bricks, 234 branch-switch candidates, 78 valid branch-switch pairs, and 94 shared obstruction-prime events. Every observed shared obstruction-prime event satisfied the congruence r 2 ≡ s 2 (mod p). There were 94 successful predictions and zero failures. The admissible shared obstruction-prime set observed was {13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601}. Every observed shared obstruction prime satisfied p ≡ 1 (mod 4). No claim is made that the perfect cuboid problem is solved. Rather, the work identifies a computational obstruction structure among primitive Euler bricks and provides evidence for an organized arithmetic phenomenon. 1 Introduction The perfect cuboid problem is one of the oldest unsolved problems in elementary number theory. It asks whether there exists a rectangular box whose edge lengths, face diagonals, and space diagonal are all integers. If only the three face diagonals are required to be integers, the object is known as an Euler brick. Euler bricks are known to exist, but adding the final space-diagonal condition has proven far more restrictive. 1 The present investigation began as a search for structural patterns among primitive Euler bricks. Rather than studying individual examples in isolation, the goal was to compare different bricks and determine whether common obstruction mechanisms exist. The resulting analysis revealed a branch-switch phenomenon involving shared obstruction primes and modular congruences. The persistence of this phenomenon through a search range exceeding one billion motivates the present report. All computations reported in this paper are empirical. The observed congruence relations and prime-structure patterns should be interpreted as computational evidence rather than proven theorems. No proof of the perfect cuboid problem is claimed. 2 Euler Bricks and Obstruction Quantities A primitive Euler brick is a triple (a, b, c) satisfying a 2 + b 2 = d 2 1 , a2 + c 2 = d 2 2 , b2 + c 2 = d 2 3 , with gcd(a, b, c) = 1. The perfect cuboid condition would additionally require a 2 + b 2 + c 2 = D2 . For each primitive Euler brick define S = a 2 + b 2 + c 2 . If S is not a square, then the brick fails to be a perfect cuboid. The prime factorization of S therefore contains direct information about the obstruction pre- venting the space diagonal from becoming integral. Primes appearing to odd exponent in the factorization of S are called obstruction primes. 3 The Branch-Switch Framework Consider two primitive Euler bricks A = (a, b, c) and B = (x, y, z). A branch-switch relation occurs when x a = z c = r while y b = s with r ̸= s. Thus two coordinates scale by a common rational factor while the remaining coordinate scales differently. This creates a structured relationship between two Euler bricks and allows their ob- struction behavior to be compared directly. 2 4 Main Computational Observation Suppose a prime p appears to odd exponent in both SA and SB. The central observation of the investigation is that every observed shared obstruction-prime event satisfied r 2 ≡ s 2 (mod p). Equivalently, (r − s)(r + s) ≡ 0 (mod p). This means every shared obstruction event occurs through one of two channels: r ≡ s (mod p) or r ≡ −s (mod p). The persistence of this congruence across the full computation is the principal phenomenon reported in this work. 5 Why This Is Interesting The perfect cuboid problem is difficult because Euler bricks are already constrained objects, and the space-diagonal square condition is even more restrictive. At first glance, the obstruction primes of different Euler bricks might seem unrelated. Each brick has its own value S = a 2 + b 2 + c 2 and therefore its own factorization. The branch-switch phenomenon suggests something deeper. When two primitive Euler bricks are connected by a specific rational scaling relation, shared obstruction primes appear to obey a rigid modular law. In simple terms: • Euler bricks fail the perfect-cuboid condition when S is not square. • Odd-exponent primes explain that failure. • Branch-switch pairs reveal that some of those primes are shared in a highly constrained way. • The constraint survived a large search through 1.01 × 109 . 6 Computational Methodology The computation was performed in two major stages. First, primitive Euler bricks were generated by searching for compatible Pythagorean structures. Since an Euler brick requires three square face diagonals, the search was organized around shared legs of Pythagorean triples. Second, the resulting primitive Euler bricks were merged and tested for branch-switch relation- ships. For each valid branch-switch pair, the obstruction quantities SA and SB were factored, their shared odd-exponent obstruction primes were identified, and the congruence r 2 ≡ s 2 (mod p) 3 was tested. The billion-scale computation used a chunked disk-backed strategy to avoid memory failure. Instead of storing the entire search space in memory, the range was divided into intervals. Each interval produced a brick file, and all brick files were later merged and deduplicated. The final search included the standard one-billion frontier and an additional ten million beyond it, reaching 1.01 × 109 . This extra extension was included to show that the phenomenon did not stop exactly at the round- number boundary of one billion. 7 Primary Verification Results The final merged dataset contained the following results. Quantity Result Search bound 1.01 × 109 Merged primitive Euler bricks 1968 Branch-switch candidates checked 234 Valid branch-switch pairs 78 Shared obstruction-prime events 94 Successful predictions 94 Failed events 0 Prediction rate 1.0 The most important line is 94/94. Every observed shared obstruction-prime event satisfied the predicted congruence. There were no denominator-blocked events and no failures. This does not constitute a proof for all Euler bricks, but it is strong computational evidence that the branch-switch obstruction congruence is a real structure rather than a small-sample accident. 8 The Shared Obstruction Primes The final admissible shared obstruction-prime set was {13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601}. Their observed frequencies were: 4 Prime Frequency 13 56 17 2 37 12 41 4 53 2 61 2 73 2 97 4 109 2 173 2 181 2 229 2 601 2 The prime 13 dominates the dataset. It appears in 56 of the 94 shared obstruction events. The prime 37 appears 12 times. Most other admissible primes appear only twice. This hierarchy is one of the main discoveries. It suggests that some obstruction primes partici- pate broadly across many branch-switch events, while others appear rarely. 9 The p ≡ 1 (mod 4) Observation Every shared obstruction prime observed satisfied p ≡ 1 (mod 4). No exceptions were found. The final test returned an empty set of shared primes outside the residue class 1 (mod 4). This makes the p ≡ 1 (mod 4) pattern one of the strongest structural findings in the dataset. A future proof may need to explain why the branch-switch construction filters shared obstruction primes into this residue class. 10 Channel Balance Since r 2 − s 2 = (r − s)(r + s), shared obstruction events can be classified according to whether they arise through the r−s channel or the r + s channel. The final counts were: Channel Count r − s 46 r + s 48 This near-perfect balance is important. It shows that the phenomenon is not explained by only one congruence direction. Both channels are active almost equally. That balance may indicate an underlying symmetry in the branch-switch mechanism. 5 11 Survival-Sieve Chronology The admissible prime set did not appear all at once. It emerged gradually as the search bound increased. Checkpoint Admissible shared primes 100M none 200M none 300M 13, 61, 73 400M 13, 61, 73 500M 13, 37, 41, 61, 73 600M 13, 37, 41, 61, 73, 109 700M 13, 37, 41, 53, 61, 73, 109, 173, 181, 229 800M 13, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601 900M unchanged 1.00B 13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601 1.01B unchanged The late appearance of 17 near the one-billion frontier is especially important. It shows that smaller searches would have missed part of the admissible-prime structure. This also explains why the full 1.01B computation was necessary. The structure was still revealing new information very late in the search. 12 First-Appearance Data The first observed appearances were: Prime First appearance 13 241236048 17 936686415 37 475400016 41 475400016 53 673548925 61 288195405 73 288195405 97 753049583 109 512752240 173 673548925 181 667287680 229 609918400 601 773625600 This chronology shows that the admissible set is not merely a small-bound phenomenon. Several primes appear only after hundreds of millions of search depth. The prime 601 first appeared after 773 million, demonstrating that larger admissible primes can emerge late but still obey the same congruence rule. 6 13 Prime Gap Structure The admissible prime sequence is: 13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601. The raw gaps are: 4, 20, 4, 12, 8, 12, 24, 12, 64, 8, 48, 372. The largest jump is 229 → 601, with gap 372. This shows that the admissible-prime set is sparse. The jump to 601 is especially notable because it shows that the phenomenon is not restricted to only the smallest primes. The normalized gap analysis was exploratory. The sample size of 13 primes is too small for strong statistical conclusions. Therefore, the gap analysis should be interpreted as descriptive rather than as evidence for a broad distribution law. 14 Clean Shared-Prime Network A clean event-only network was built by connecting primes that appeared together in the same shared obstruction event. Edge Count (13, 37) 4 (61, 73) 2 (53, 173) 2 (13, 181) 2 (17, 41) 2 (37, 41) 2 (97, 601) 2 This network is small but informative. It shows which admissible primes co-occur in the actual branch-switch shared-obstruction events. The earlier broader network test included primes outside the final admissible shared-prime set. The cleaned network avoids that issue and records only event-level shared-prime co-occurrence. 15 What Was Observed The computation found a structured relationship between branch-switch pairs of primitive Euler bricks and their obstruction primes. The observations can be summarized as follows: 1. A branch-switch congruence phenomenon was observed. 2. Every observed shared obstruction-prime event satisfied r 2 ≡ s 2 (mod p). 7 3. The prediction rate through 1.01 × 109 was 100%. 4. No failures were observed. 5. Every admissible shared obstruction prime satisfied p ≡ 1 (mod 4). 6. Prime 13 dominated the event frequency table. 7. The two congruence channels r − s and r + s were almost perfectly balanced. 8. New admissible primes appeared very late in the search. 9. The pattern continued beyond the one-billion boundary. This is why the computation is meaningful. It did not merely count Euler bricks. It revealed a repeatable obstruction pattern linking rational branch-switch ratios to shared odd-exponent prime divisors of the space-diagonal obstruction quantity. 16 What Was Not Proven This work does not prove that no perfect cuboid exists. It also does not construct a perfect cuboid. Therefore, the perfect cuboid problem remains unresolved. This work also does not prove the Riemann Hypothesis or any other major conjecture in analytic number theory. The spectral-style and gap-spacing tests are exploratory only. They may motivate future ques- tions, but they do not establish a theorem about zeta zeros or prime distributions. The honest interpretation is that a branch-switch obstruction phenomenon was observed and verified computationally through 1.01 × 109 , but a general proof remains open. 17 Future Work The next mathematical goal is to derive the congruence r 2 ≡ s 2 (mod p) from the branch-switch equations directly. Other future directions include: • proving or disproving the branch-switch congruence in general; • explaining why all observed shared obstruction primes satisfy p ≡ 1 (mod 4); • classifying the admissible shared-prime set; • explaining the dominance of prime 13; • extending the computation beyond 1.01 × 109 ; • comparing results across different branch-switch orientations; • developing a stronger theoretical connection to the perfect cuboid obstruction. 8 18 Conclusion A large-scale computational investigation of primitive Euler bricks revealed a branch-switch ob- struction phenomenon verified through 1.01 × 109 . The final merged dataset contained 1968 primitive Euler bricks. From these, 234 branch-switch candidates were checked, 78 valid branch-switch pairs were found, and 94 shared obstruction-prime events were tested. All 94 events satisfied r 2 ≡ s 2 (mod p). There were zero failures. The admissible shared obstruction primes were {13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601}. All of them satisfied p ≡ 1 (mod 4). The results do not solve the perfect cuboid problem, but they identify a computational obstruc- tion structure among primitive Euler bricks and provide a concrete foundation for future theoretical work. A Minimal Reproducible Euler-Brick Generator The following code provides a simple low-memory test for finding primitive Euler bricks up to a chosen limit. This is not the full FAST V3 billion-scale engine. It is included as a small reproducible demonstration. from math import gcd, isqrt import time LIMIT = 1000000 start = time.time() def is_square(n): r = isqrt(n) return r * r == n def primitive_triples(limit): m_max = isqrt(limit) + 1 for m in range(2, m_max): for n in range(1, m): if ((m - n) & 1) == 0: continue if gcd(m, n) != 1: continue a = mm - nn b = 2mn c = mm + nn 9 if c > limit: continue yield (min(a,b), max(a,b), c) triplesbyleg = {} count = 0 brick_count = 0 for a,b,c in primitive_triples(LIMIT): count += 1 if count % 10000 == 0: print( f"triples={count} " f"legs={len(triplesbyleg)} " f"bricks={brick_count}" ) for leg, other in ((a,b), (b,a)): if leg not in triplesbyleg: triplesbyleg[leg] = [] for prevother, prevhyp in triplesbyleg[leg]: x = prev_other y = other if not is_square(xx + yy): continue g = gcd(gcd(leg, x), y) if g != 1: continue brick = tuple(sorted((leg, x, y))) print("Euler brick:", brick) brick_count += 1 triplesbyleg[leg].append((other, c)) print() print("DONE") print("Primitive triples:", count) print("Euler bricks found:", brick_count) print("Elapsed:", round(time.time() - start, 2), "seconds") B Final Verification Output MERGE + THEOREM TEST STARTED 10 RUNDIR = /content/drive/MyDrive/branchswitchruns1B_chunks Brick files found: 81 Merged primitive bricks: 1968 THEOREM TEST COMPLETE Merged primitive Euler bricks: 1968 Checked branch-switch candidates: 234 Valid branch-switch pairs with shared obstruction primes: 78 Shared obstruction events: 94 Predicted events: 94 Failed events: 0 Denominator blocked events: 0 Prediction rate: 1.0 Distinct shared obstruction primes: [13, 17, 37, 41, 53, 61, 73, 97, 109, 173, 181, 229, 601] Shared primes not 1 mod 4: [] References [1] R. K. Guy, Unsolved Problems in Number Theory, Springer. [2] L. E. Dickson, History of the Theory of Numbers, Volume II. [3] G. H. Hardy and E. M. Wright, An Introduction to the Theory of Numbers, Oxford University Press. [4] D. A. Cox, Primes of the Form x 2 + ny2 , Wiley. 11
Attachments:
