matthewdeanmartin · August 24, 2025 17:58 · matthewdeanmartin · Aug 24, 2025
diff --git a/randomish.py b/randomish.py
 import collections
 import math
 import re


 def seeded_text_key_scramble(source_text, secret_key, start_word_index, num_digits, verbose=False):
    """
    Generates a sequence of pseudo-random digits based on a source text and a secret key.

    Args:
        source_text (str): The text to use as the source of entropy.
        secret_key (str): A string of digits to use as the key.
        start_word_index (int): The index of the word to start from in the text.
        num_digits (int): The total number of digits to generate.
        verbose (bool): If True, prints the step-by-step actions for generation.

    Returns:
        str: The generated string of digits.
    """
    # Sanitize the source text by keeping only letters and spaces, and splitting into words.
    words = re.sub(r'[^a-zA-Z\s]', '', source_text.lower()).split()
    if not words:
        raise ValueError("Source text contains no usable words.")

    generated_digits = []
    word_index = start_word_index % len(words)
    key_index = 0

    # The main loop, generating two digits per iteration.
    num_iterations = (num_digits + 1) // 2

    for i in range(num_iterations):
        if len(generated_digits) >= num_digits:
            break

        if verbose: print(f"\n--- Iteration {i + 1} ---")

        # 1. Identify the current word and count its letters (L).
        current_word = words[word_index]
        l = len(current_word)
        if verbose: print(f"ACTION: Point to word '{current_word}'. Count its letters. L = {l}.")

        # 2. Get the current key digit (k).
        k = int(secret_key[key_index])
        if verbose: print(f"ACTION: Recall the next secret key digit. k = {k}.")

        # 3. Calculate the first digit (D1).
        d1 = (l + k) % 10
        generated_digits.append(str(d1))
        if verbose: print(f"ACTION: Calculate first digit: ({l} + {k}) mod 10 = {d1}. Write down '{d1}'.")

        if len(generated_digits) >= num_digits:
            break

        # 4. Calculate the second digit (D2).
        letter_pos_in_word = (d1 - 1) % l if l > 0 else 0
        letter = current_word[letter_pos_in_word]
        alphabet_pos = ord(letter) - ord('a') + 1
        d2 = alphabet_pos % 10
        generated_digits.append(str(d2))
        if verbose:
            print(f"ACTION: Count {d1} letters into '{current_word}' to find the letter '{letter}'.")
            print(
                f"ACTION: Find alphabet position of '{letter}' ({alphabet_pos}). Calculate second digit: {alphabet_pos} mod 10 = {d2}. Write down '{d2}'.")

        # 5. Find the next word.
        words_to_advance = d2 + 1
        word_index = (word_index + words_to_advance) % len(words)
        if verbose:
            print(f"ACTION: Count {words_to_advance} words forward to find the next word ('{words[word_index]}').")
            print(f"   > Generated so far: {''.join(generated_digits)}")

        # 6. Advance the key index, looping if necessary.
        key_index = (key_index + 1) % len(secret_key)

    return "".join(generated_digits)


 def analyze_randomness(digits_str):
    """
    Performs several statistical tests on a string of digits to check for randomness.
    """
    print("--- Statistical Randomness Analysis ---")

    # 1. Frequency Analysis
    print("\n1. Digit Frequency Distribution:")
    counts = collections.Counter(digits_str)
    total_digits = len(digits_str)
    expected_count = total_digits / 10.0

    print(f"Total Digits: {total_digits}")
    print(f"Expected count per digit: {expected_count:.1f}")
    print("-" * 30)
    for digit in sorted(counts.keys()):
        print(f"Digit {digit}: {counts[digit]:>4} times ({(counts[digit] / total_digits) * 100:5.2f}%)")
    print("-" * 30)

    # 2. Chi-Squared Test for Uniformity
    chi_squared_stat = sum([(counts.get(str(d), 0) - expected_count) ** 2 / expected_count for d in range(10)])
    critical_value = 16.919  # p=0.05, df=9

    print("\n2. Chi-Squared Test for Uniformity:")
    print(f"Chi-Squared Statistic: {chi_squared_stat:.4f}")
    print(f"Critical Value (p=0.05, df=9): {critical_value}")
    if chi_squared_stat < critical_value:
        print("Result: The distribution appears uniform. We DO NOT reject the null hypothesis.")
    else:
        print("Result: The distribution does NOT appear uniform. We REJECT the null hypothesis.")

    # 3. Runs Test (Simple version: count of adjacent identical digits)
    runs = 0
    for i in range(total_digits - 1):
        if digits_str[i] == digits_str[i + 1]:
            runs += 1

    expected_runs = (total_digits - 1) / 10.0

    print("\n3. Simple Runs Test (Adjacent Repeats):")
    print(f"Observed number of adjacent identical digits: {runs}")
    print(f"Expected number of adjacent identical digits: {expected_runs:.1f}")
    if abs(runs - expected_runs) < 3 * math.sqrt(expected_runs):  # Check within ~3 std deviations
        print("Result: The number of runs is within the expected range for a random sequence.")
    else:
        print("Result: The number of runs is outside the expected range.")


 # --- Main Execution ---
 if __name__ == "__main__":
    lorem_ipsum_text = """
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
    Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
    Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
    Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam,
    eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
    Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores
    eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet,
    consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam
    quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam,
    nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse
    quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
    """

    SECRET_KEY = "3141592653"
    START_WORD_INDEX = 13
    NUM_DIGITS_TO_GENERATE = 1000

    # --- VERBOSE DEMONSTRATION ---
    # Show the step-by-step process for the first 20 digits to see how a human would do it.
    print("=" * 50)
    print("--- Human Action Simulation (First 20 Digits) ---")
    print("=" * 50)
    seeded_text_key_scramble(
        source_text=lorem_ipsum_text,
        secret_key=SECRET_KEY,
        start_word_index=START_WORD_INDEX,
        num_digits=20,
        verbose=True
    )

    # --- FULL GENERATION AND ANALYSIS ---
    print("\n\n" + "=" * 50)
    print(f"--- Full Run: Generating {NUM_DIGITS_TO_GENERATE} Digits for Analysis ---")
    print("=" * 50)
    random_number = seeded_text_key_scramble(
        source_text=lorem_ipsum_text,
        secret_key=SECRET_KEY,
        start_word_index=START_WORD_INDEX,
        num_digits=NUM_DIGITS_TO_GENERATE,
        verbose=False  # Turn off verbose for the full run
    )

    print(f"\n--- Generated {len(random_number)}-Digit Number ---")
    for i in range(0, len(random_number), 100):
        print(random_number[i:i + 100])
    print("\n")

    analyze_randomness(random_number)
	import collections
	import math
	import re


	def seeded_text_key_scramble(source_text, secret_key, start_word_index, num_digits, verbose=False):
	"""
	Generates a sequence of pseudo-random digits based on a source text and a secret key.

	Args:
	source_text (str): The text to use as the source of entropy.
	secret_key (str): A string of digits to use as the key.
	start_word_index (int): The index of the word to start from in the text.
	num_digits (int): The total number of digits to generate.
	verbose (bool): If True, prints the step-by-step actions for generation.

	Returns:
	str: The generated string of digits.
	"""
	# Sanitize the source text by keeping only letters and spaces, and splitting into words.
	words = re.sub(r'[^a-zA-Z\s]', '', source_text.lower()).split()
	if not words:
	raise ValueError("Source text contains no usable words.")

	generated_digits = []
	word_index = start_word_index % len(words)
	key_index = 0

	# The main loop, generating two digits per iteration.
	num_iterations = (num_digits + 1) // 2

	for i in range(num_iterations):
	if len(generated_digits) >= num_digits:
	break

	if verbose: print(f"\n--- Iteration {i + 1} ---")

	# 1. Identify the current word and count its letters (L).
	current_word = words[word_index]
	l = len(current_word)
	if verbose: print(f"ACTION: Point to word '{current_word}'. Count its letters. L = {l}.")

	# 2. Get the current key digit (k).
	k = int(secret_key[key_index])
	if verbose: print(f"ACTION: Recall the next secret key digit. k = {k}.")

	# 3. Calculate the first digit (D1).
	d1 = (l + k) % 10
	generated_digits.append(str(d1))
	if verbose: print(f"ACTION: Calculate first digit: ({l} + {k}) mod 10 = {d1}. Write down '{d1}'.")

	if len(generated_digits) >= num_digits:
	break

	# 4. Calculate the second digit (D2).
	letter_pos_in_word = (d1 - 1) % l if l > 0 else 0
	letter = current_word[letter_pos_in_word]
	alphabet_pos = ord(letter) - ord('a') + 1
	d2 = alphabet_pos % 10
	generated_digits.append(str(d2))
	if verbose:
	print(f"ACTION: Count {d1} letters into '{current_word}' to find the letter '{letter}'.")
	print(
	f"ACTION: Find alphabet position of '{letter}' ({alphabet_pos}). Calculate second digit: {alphabet_pos} mod 10 = {d2}. Write down '{d2}'.")

	# 5. Find the next word.
	words_to_advance = d2 + 1
	word_index = (word_index + words_to_advance) % len(words)
	if verbose:
	print(f"ACTION: Count {words_to_advance} words forward to find the next word ('{words[word_index]}').")
	print(f" > Generated so far: {''.join(generated_digits)}")

	# 6. Advance the key index, looping if necessary.
	key_index = (key_index + 1) % len(secret_key)

	return "".join(generated_digits)


	def analyze_randomness(digits_str):
	"""
	Performs several statistical tests on a string of digits to check for randomness.
	"""
	print("--- Statistical Randomness Analysis ---")

	# 1. Frequency Analysis
	print("\n1. Digit Frequency Distribution:")
	counts = collections.Counter(digits_str)
	total_digits = len(digits_str)
	expected_count = total_digits / 10.0

	print(f"Total Digits: {total_digits}")
	print(f"Expected count per digit: {expected_count:.1f}")
	print("-" * 30)
	for digit in sorted(counts.keys()):
	print(f"Digit {digit}: {counts[digit]:>4} times ({(counts[digit] / total_digits) * 100:5.2f}%)")
	print("-" * 30)

	# 2. Chi-Squared Test for Uniformity
	chi_squared_stat = sum([(counts.get(str(d), 0) - expected_count) ** 2 / expected_count for d in range(10)])
	critical_value = 16.919 # p=0.05, df=9

	print("\n2. Chi-Squared Test for Uniformity:")
	print(f"Chi-Squared Statistic: {chi_squared_stat:.4f}")
	print(f"Critical Value (p=0.05, df=9): {critical_value}")
	if chi_squared_stat < critical_value:
	print("Result: The distribution appears uniform. We DO NOT reject the null hypothesis.")
	else:
	print("Result: The distribution does NOT appear uniform. We REJECT the null hypothesis.")

	# 3. Runs Test (Simple version: count of adjacent identical digits)
	runs = 0
	for i in range(total_digits - 1):
	if digits_str[i] == digits_str[i + 1]:
	runs += 1

	expected_runs = (total_digits - 1) / 10.0

	print("\n3. Simple Runs Test (Adjacent Repeats):")
	print(f"Observed number of adjacent identical digits: {runs}")
	print(f"Expected number of adjacent identical digits: {expected_runs:.1f}")
	if abs(runs - expected_runs) < 3 * math.sqrt(expected_runs): # Check within ~3 std deviations
	print("Result: The number of runs is within the expected range for a random sequence.")
	else:
	print("Result: The number of runs is outside the expected range.")


	# --- Main Execution ---
	if __name__ == "__main__":
	lorem_ipsum_text = """
	Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
	Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
	Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
	Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
	Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam,
	eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
	Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores
	eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet,
	consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam
	quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam,
	nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse
	quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
	"""

	SECRET_KEY = "3141592653"
	START_WORD_INDEX = 13
	NUM_DIGITS_TO_GENERATE = 1000

	# --- VERBOSE DEMONSTRATION ---
	# Show the step-by-step process for the first 20 digits to see how a human would do it.
	print("=" * 50)
	print("--- Human Action Simulation (First 20 Digits) ---")
	print("=" * 50)
	seeded_text_key_scramble(
	source_text=lorem_ipsum_text,
	secret_key=SECRET_KEY,
	start_word_index=START_WORD_INDEX,
	num_digits=20,
	verbose=True
	)

	# --- FULL GENERATION AND ANALYSIS ---
	print("\n\n" + "=" * 50)
	print(f"--- Full Run: Generating {NUM_DIGITS_TO_GENERATE} Digits for Analysis ---")
	print("=" * 50)
	random_number = seeded_text_key_scramble(
	source_text=lorem_ipsum_text,
	secret_key=SECRET_KEY,
	start_word_index=START_WORD_INDEX,
	num_digits=NUM_DIGITS_TO_GENERATE,
	verbose=False # Turn off verbose for the full run
	)

	print(f"\n--- Generated {len(random_number)}-Digit Number ---")
	for i in range(0, len(random_number), 100):
	print(random_number[i:i + 100])
	print("\n")

	analyze_randomness(random_number)
No results found