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] 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 < 25000$ within 90 minutes. It also identifies the pair $(p, q) = (17,3313)$ as noted in JoshuaZ's [comment][4], for the sole non-coprime example in this range.

**Computation**  

        ...$time python3 check_primes_parallel.py
    Pair not relatively prime: p=17, q=3313, gcd=112643
    
    real	88m57.158s
    user	838m44.435s
    sys	0m9.762s


**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=12):
        # 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 = 25000 # 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