**This page is a work in progress at the moment.** On this page, I'm going to present evidence for the following statement: "Despite the fact that some components are similar to concepts described in other papers, I have invented all components of this algorithm independently." # Nature of evidence Generally, the evidence is as follows. I have come up with the ideas presented in the paper some time ago, before similar ideas were published in other papers. I haven't shared my ideas at the time when I was inventing them for the reasons listed below, but I was using a service like [OpenTimestamps](https://opentimestamps.org/) to be able to prove that I have invented it (and before I learned about the existence of OpenTimestamps, I was using a Python script that generates a hash of a file and I was uploading it to some websites), if I need to prove it later for any reason. OpenTimestamps is a program that creates a hash of a file and sends it to Bitcoin blockchain. The block containing the hash also contains the time of when the block was created. Therefore, it is a proof that a file existed at a certain time. In my case, I was using it as a proof of invention by putting my name/nickname in the document describing the invention and then timestamping it using OpenTimestamps or my Python script. The Python script that I used previously worked in a similar way, but I was uploading hash to a website like pastebin.com. %% The reasons why I didn't share my ideas as I was coming up with them: 1. I wasn't sure if it's socially beneficial to share ideas that might contribute to open AI progress, given the risks of AI. 2. I wanted to have some competitive advantage which I believed might be useful to get funding to work on projects implementing those ideas. 3. I had other things to do that I considered equally or more important than sharing it (especially that it takes me a lot of time to consider I should share it). %% # Files For now, I include one proof file, but I plan to include at least one more proof file with an earlier date (from the previous year). I need to firstly figure out which file I want to share here because I have many of them. It can take me some time, so I will only upload that file, if my ARC paper will become published by ARC because otherwise nobody will read that anyway, so there's no point for me to waste time on it. Link to the proof file: https://gitlab.com/damc4/ideas/-/blob/master/public/other/2025-04-14_Empirical_Theorist.md.proof In order to verify it, you need to download that file and run the following Python script with the path to the above file as argument. The script will verify if the proof is correct (and tell you what to do to verify it) and will explain how the proof works. The Python script: ```Python import sys import os import hashlib import json import base64 def load_json(input_filepath): """Loads data from a JSON file""" with open(input_filepath, 'r', encoding='utf-8') as f: data = json.load(f) return data def decode_base64_and_save(content, output_filepath): """Decodes base64 content and saves it to a file""" decoded_content = base64.b64decode(content.encode('utf-8')) with open(output_filepath, 'wb') as f: f.write(decoded_content) return decoded_content if __name__ == '__main__': if len(sys.argv) < 2: print("Usage: hashgen-check input_file [output_file]") sys.exit(1) input_filepath = sys.argv[1] if not os.path.isfile(input_filepath): print("Error: input file does not exist") sys.exit(1) if len(sys.argv) > 2: output_filepath = sys.argv[2] else: # Use default output file path input_basename = os.path.basename(input_filepath) if input_basename.endswith('.json'): input_basename = input_basename[:-5] output_filename = f"decoded_{input_basename}" output_dir = os.path.dirname(input_filepath) output_filepath = os.path.join(output_dir, output_filename) # Load JSON data json_data = load_json(input_filepath) # Construct a JSON object with inventor property and base64-encoded content data = { 'inventor': json_data['inventor'], 'content': json_data['content'], } json_data_encoded = json.dumps(data, sort_keys=True) # Decode base64 content and save it to a file decoded_content = decode_base64_and_save(json_data['content'], output_filepath) print("This file contains an encoded file and a potential proof that this file existed at a certain date.") print("The encoded file has been now decoded and saved to " + output_filepath) # Calculate hash of the JSON-encoded content calculated_hash = hashlib.sha256(json_data_encoded.encode('utf-8')).hexdigest() # Compare the calculated hash with the hash in the JSON file if calculated_hash == json_data['hash']: print("The hash is correct.") print(f"Hash: {calculated_hash}") print(f"Link(s): " + json_data['link']) print(f"Inventor: " + json_data['inventor']) print("") print(f"You should now check if at least one of the above links contain the above hash. If that's the case, then it means that the above-mentioned person is the inventor of the content in the encoded file, or more specifically they were aware of the content of the file at the time when the content accessible at the above links has been uploaded.") print("") print("That is because this file contains a hash of the content of the decoded file concatenated with the inventor's name. If the above-mentioned hash has been uploaded somewhere, then it means that the content existed at the time of the upload and above mentioned person was aware of the content.") print("") print("Keep in mind that sometimes some links can stop working for example because some platforms remove content uploaded long ago. But the other links might still work and consitute a proof.") print("") else: print("The hash is incorrect. This file seems to be invalid and can't be used to prove anything.") print("Decoded file saved to:", output_filepath) ```