In connection with the historical development of the classification of finite simple groups, I am interested in a particular aspect that seems to be less well-documented than the main narrative of discovery and confirmation. Specifically, I am referring to the question (posted 11 years ago) [Groups that do not exist][1], which asked whether there were finite simple groups conjectured at some point that turned out not to exist.

To build upon that discussion, I am looking for a very specific kind of artifact from the history of group theory: explicit character tables for such conjectured but non-existent finite simple groups, if they ever were constructed. My understanding is that character tables were computed for many groups as part of the classification effort. 

**Question**: Could anyone provide references to or copies of explicit (complete) character tables developed for finite simple groups that were later shown not to exist?

If possible, please elucidate the reasoning behind the exclusion.


______
_____

Regarding [Feit-Thompson Conjecture][2] [FT62] mentioned in Dave Benson's [answer][3], which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 50000$ within 35 hours. It also identifies the pair $(p, q) = (17,3313)$, discovered in [S71], as noted in JoshuaZ's [comment][4], for the sole non-coprime example in this range. The range could be significantly improved by the method in [S71].     

*Bonus question*: Is there any other pair $(p,q)$ of this kind? 

More recent checkings can be found in [G04] at B25 on page 125:

[![enter image description here][6]][6]  

The last ckecking mentioned above is [DK04]. See also [M09].

*References*  

[FT62] Feit, Walter; Thompson, John G. A solvability criterion for finite groups and some consequences. Proc. Nat. Acad. Sci. U.S.A. 48 (1962), 968--970.  
[S71] Stephens, N. M. On the Feit-Thompson conjecture. Math. Comp. 25 (1971), 625.   
[DK04] Dilcher, Karl; Knauer, Joshua. On a conjecture of Feit and Thompson. High primes and misdemeanours: lectures in honour of the 60th birthday of Hugh Cowie Williams, 169--178, Fields Inst. Commun., 41, Amer. Math. Soc., Providence, RI, 2004.    
[G04] Guy, Richard K. Unsolved problems in number theory. Third edition. Problem Books in Mathematics. Springer-Verlag, New York, 2004. xviii+437 pp.   
[M09] Motose, Kaoru. Notes on the Feit-Thompson conjecture. Proc. Japan Acad. Ser. A Math. Sci. 85 (2009), no. 2, 16--17.

______

**Computation**  

        ...$time python3 check_primes_parallel.py
    Pair not relatively prime: p=17, q=3313, gcd=112643
    
    real	2066m4.640s
    user	13490m17.916s
    sys	1m1.613s


**Code**  

    # check_primes_parallel.py
    from sympy import primerange, gcd
    from multiprocessing import Pool
    import itertools
    
    def check_relative_prime_and_divisibility(pair):
        p, q = pair
        num1 = (pow(p, q) - 1) // (p - 1)
        num2 = (pow(q, p) - 1) // (q - 1)
        
        d = gcd(num1, num2)
        if d == 1:
            return None
        
        if num1 % num2 == 0:
            return f"Found divisible pair: p={p}, q={q}"
        else:
            return f"Pair not relatively prime: p={p}, q={q}, gcd={d}"
    
    def find_prime_pairs(max_prime, num_cpus=8):
        # Generate a list of odd primes up to max_prime
        primes = list(primerange(3, max_prime))
        
        # Generate all unique combinations of two primes
        prime_pairs = list(itertools.combinations(primes, 2))
    
        # Create a pool of workers with the desired number of CPUs
        with Pool(processes=num_cpus) as pool:
            # Map the function over the prime pairs, distributed across the workers
            results = pool.map(check_relative_prime_and_divisibility, prime_pairs)
        
        # Filter out None results and print the rest
        for result in filter(None, results):
            print(result)
    
    # Set a maximum prime number limit according to your computational power
    max_prime = 50000 # You can adjust this value
    find_prime_pairs(max_prime)


  [1]: https://mathoverflow.net/questions/115735/groups-that-do-not-exist
  [2]: https://en.wikipedia.org/wiki/Feit–Thompson_conjecture
  [3]: https://mathoverflow.net/a/460055
  [4]: https://mathoverflow.net/questions/460049/request-for-explicit-character-tables-of-conjectured-non-existent-finite-simple#comment1192037_460055
  [5]: https://doi.org/10.2307/2005226
  [6]: https://i.sstatic.net/KZPRk.png