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, 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 mentioned in Dave Benson's answer, 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)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range. The range could be significantly improve by the method in this paper.

An other checking can be found in Guy's book (Unsolved Problems in Number Theory), at B25 on page 125:

Bonus question: Is there any other such pair in general?

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)