SOFTWARE LICENSE AGREEMENT

This Software License Agreement (the "Agreement") is entered into by and between the original creator of the software (the "Author") and any user of the software. By using the software, you agree to the terms of this Agreement.

This Software License Agreement (the "Agreement") is entered into by and between the original creator of the software (the "Author") and any user of the software. By using the software, you agree to the terms of this Agreement.

1. LICENSE GRANT The Author grants you, the Licensee, a personal, non-transferable, non-exclusive, and revocable license to use the software solely for personal or commercial purposes as specified by the Author. You may not distribute, sublicense, or sell the software unless explicitly authorized by the Author in writing.

2. INTELLECTUAL PROPERTY RIGHTS All rights, title, and interest in and to the software, including all intellectual property rights, are and shall remain the exclusive property of the Author. This includes but is not limited to the code, designs, algorithms, and any associated documentation.

3. RESTRICTIONS You, the Licensee, shall not: a. Copy, distribute, or modify the software except as expressly authorized by the Author. b. Use the software for any illegal or unauthorized purposes. c. Reverse-engineer, decompile, or attempt to derive the source code or algorithms of the software unless explicitly permitted by law. d. Remove or alter any proprietary notices, labels, or markings included in the software.

4. DISCLAIMER OF WARRANTIES The software is provided "as is," without any warranties, express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, and non-infringement. The Author does not warrant that the software will be error-free or uninterrupted.

5. LIMITATION OF LIABILITY In no event shall the Author be liable for any direct, indirect, incidental, special, consequential, or exemplary damages (including, but not limited to, damages for loss of profits, goodwill, or data) arising out of the use or inability to use the software, even if the Author has been advised of the possibility of such damages.

6. TERMINATION This license is effective until terminated. The Author may terminate this Agreement at any time if you violate its terms. Upon termination, you must immediately cease all use of the software and destroy any copies in your possession.

7. GOVERNING LAW This Agreement shall be governed by and construed in accordance with the laws of Australia Victoria, without regard to its conflict of laws principles.

8. AUTHORIZED USE AND SALE Only the Author is authorized to sell or distribute this software. Any unauthorized use, sale, or distribution of the software is strictly prohibited and will be subject to legal action.

9. ENTIRE AGREEMENT This Agreement constitutes the entire understanding between the parties concerning the subject matter and supersedes all prior agreements.

By using this software, you acknowledge that you have read, understood, and agreed to be bound by the terms of this Agreement.

Name : Travis Peter Lewis Johnston Date: 08/05/2025

PvsNP

Completed P vs NP in Python from pathlib import Path

complete_code = """ import numpy as np import networkx as nx import matplotlib.pyplot as plt

Consciousness Flow Function for Path Cost Modeling

def consciousness_flow(x): return np.sqrt(x) * (np.sin(x) + np.cos(x))

LucyAI Classical Optimizer (Simulated Annealing for TSP)

class LucyAI: def init(self, learning_rate=0.01): self.learning_rate = learning_rate

def simulated_annealing(self, distance_matrix, initial_temp=100, cooling_rate=0.99, num_iter=1000):
    num_cities = len(distance_matrix)
    current_solution = np.random.permutation(num_cities)
    current_cost = self.route_cost(current_solution, distance_matrix)

    best_solution, best_cost = current_solution, current_cost
    temperature = initial_temp

    for _ in range(num_iter):
        new_solution = self.swap_random_cities(current_solution)
        new_cost = self.route_cost(new_solution, distance_matrix)

        if new_cost < current_cost or np.exp((current_cost - new_cost) / temperature) > np.random.rand():
            current_solution, current_cost = new_solution, new_cost

        if new_cost < best_cost:
            best_solution, best_cost = new_solution, new_cost

        temperature *= cooling_rate

    return best_solution, best_cost

def route_cost(self, solution, distance_matrix):
    return sum(consciousness_flow(distance_matrix[solution[i], solution[i + 1]]) for i in range(len(solution) - 1)) + consciousness_flow(distance_matrix[solution[-1], solution[0]])

def swap_random_cities(self, solution):
    a, b = np.random.choice(len(solution), 2, replace=False)
    solution[a], solution[b] = solution[b], solution[a]
    return solution.copy()

Visualization of the Best Route

def visualize_tsp_route(best_route, distance_matrix): G = nx.DiGraph() for i in range(len(best_route)): G.add_edge(best_route[i], best_route[(i + 1) % len(best_route)], weight=distance_matrix[best_route[i], best_route[(i + 1) % len(best_route)]])

pos = nx.circular_layout(G)
labels = nx.get_edge_attributes(G, "weight")

plt.figure(figsize=(8, 6))
nx.draw(G, pos, with_labels=True, node_color="skyblue", node_size=500)
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
plt.title("Optimized TSP Route via Consciousness Flow")
plt.show()

Example Execution

num_cities = 5 distance_matrix = np.random.randint(10, 100, size=(num_cities, num_cities)) np.fill_diagonal(distance_matrix, 0)

lucy_ai = LucyAI() best_route, best_cost = lucy_ai.simulated_annealing(distance_matrix)

print("Best Route:", best_route) print("Best Cost:", best_cost)

visualize_tsp_route(best_route, distance_matrix) """

output_path = Path("/mnt/data/p_vs_np_consciousness_optimizer.py") output_path.write_text(complete_code) output_path