Chaotic-Phasors

Overview

TLDR; attempt to build a CRHF based on the state of a dynamical system.

This project is a simulation of a system of phasors (rotating vectors) organized in multiple circles and attempt to harness a deterministic chaotic system to create a unique encryption system. In this project, each circle starts with a set number of phasors with their own initial angles and angular speeds. The phasors can collide both within their own circle and with phasors from other circles "cross-fire" style. Can perfectly re-run in microseconds (any starting position will produce same finishing position and interim conditions).

Simulation output (sum of phasors at a randomly sampled set of T**; expect to make the output non-continuous, or map elements such as the collision # to state of each phasor) is the public key. These public keys (illustrative example of output below) can be easily verified in a deterministic way given private-key starting conditions (phasors, including momentum and location, and other data such as collisions numbers). An (extremely low confidence)upper-bound estimate is the time required to crack the system is on the order of $e^{66760.5}$ times the estimated age of the universe ( $4.3 \times 10^{17}$ seconds) but this needs peer review.

Example Output Gif of some of the first few frames from HTML app (collision counter since fixed)

Butterfly Effect: A 1 bit change (0.000001 addition to velocity in one node) leads to a significant change in the output

Run 1 with final node position on left, Output ("Public Key") in middle, starting conditions(Private Key) on bottom, visualized on top right

Run 2, with a 1 bit change to angular speed on the first phasor, all else the same

To-do: Establishing the NP-hardness of the problem. WIP and will invite any comments

Problem Identification

The problem involves recovering the private key ( I ) from a given sequence of time-states ( T = {T_1, T_2, \ldots, T_n} ) where each ( T_i ) represents the system state at a certain time or collision point. The deterministic chaotic system ( \mathcal{C} ) involves rotating phasors with specific dynamics and collision mechanics.

Problem Formalization

Given a deterministic chaotic system ( \mathcal{C} ), find the initial conditions ( I ) that lead to a known sequence of time-states ( T ) when evolved according to the dynamics of ( \mathcal{C} ).

Parameters

( N ) phasors, each with initial angle ( \theta_i ) and angular speed ( \omega_i )
A finite set ( M ) of collisions, affecting two phasors' angular speeds based on predefined collision rules
An evolution function ( E(S, t) ) that specifies how the state ( S ) changes over time ( t ) and upon collisions
( T = {T_1, T_2, \ldots, T_n} ), a sequence of system states at specific times or collision points

Computational Complexity Hypothesis

The problem belongs to the NP-hard class. Given a proposed solution ( I ), we can verify it in polynomial time by evolving the system ( \mathcal{C} ) using ( E(S, t) ) to generate ( T ).

Reduction to Known NP-hard Problem (Hamiltonian Path Problem)

Hamiltonian Path Problem

Given a graph ( G = (V, E) ), find a path that visits each vertex in ( V ) exactly once.

Reduction Steps

Vertex to Phasor Mapping: Each vertex ( v \in V ) is mapped to a unique phasor with specific initial conditions ( \theta_i, \omega_i ) in ( \mathcal{C} ). This mapping is a bijection and can be performed in polynomial time with respect to the size of ( V ).
Edge to Collision Mapping: Each edge ( e \in E ) is deterministically mapped to a collision event in ( M ). Collision rules mirror the structure of ( G ). This mapping is polynomial time in ( |E| ).
Path to Time-States Mapping: A Hamiltonian path ( P ) in ( G ) corresponds to a sequence of time-states ( T ) in ( \mathcal{C} ). This mapping is polynomial time and preserves problem difficulty. The difficulty preservation follows from the constraints of Hamiltonian pathing, which translate to the complexity of achieving the specified sequence ( T ).
Algorithm Adaptation: Algorithms solving Hamiltonian Path Problem in ( G ) can be adapted to find ( I ) in ( \mathcal{C} ), maintaining polynomial time complexity in ( |G| ).

Formal Proofs

Polynomial Time: All mappings are polynomial in time, which is shown by demonstrating that each mapping can be performed in ( O(n^k) ) time, where ( n ) is the size of the input and ( k ) is a constant.
Preserving Problem Difficulty: Establishing this rigorously would involve showing that any algorithm solving ( G ) can be adapted to solve for ( T ) in ( \mathcal{C} ), and vice versa, without a significant increase in computational resources.

Upper Bound Complexity Estimation of Brute-Forcing a Private Key.

4 Circles, 10 Phasors Each: The system consists of 4 circles, each containing 10 phasors, totaling 40 phasors.
Random Initialization: Angles are initialized randomly between (0) and (2\pi), and speeds are initialized randomly between (-40) and (40).
Collision Mechanics: Collisions are determined by a set size, and upon collision, phasors swap their angular momentum. There is additional "friction" added by the system during cross-circle collisions
Fixed Time Step: A fixed time step of (0.001) is used for updating the phasors.

Logic for Complexity Estimation

Angles and Speeds

For one phasor, the complexity due to angles and speeds is calculated as:
$\text{Single Phasor Complexity} = 2\pi \times 80 = 160\pi$

For all 40 phasors, the total complexity becomes:
$\text{Total Phasor Complexity} = (160\pi)^{40}$

Collision Events

The number of distinct collision pairs is $\binom{40}{2} = 780$ .
Assuming a set number of collisions (10,000), the complexity due to collision events is:
$\text{Total Collision Complexity} = 780^{10,000}$

Total Complexity

The total complexity of the system is given by:
$\text{Total Complexity} = \text{Total Phasor Complexity} \times \text{Total Collision Complexity}$

Logarithmically, this is expressed as:
$\log(\text{Total Complexity}) = 40 \log(160\pi) + 10,000 \log(780)$

Time to Crack

Using Fugaku's computational power of $442.01 \times 10^{15}$ FLOP/s, the logarithmic time required to crack the system is:
$\log(\text{Time to Crack}) = \log(\text{Total Complexity}) - \log(\text{Fugaku Speed})$

The logarithmic time required to crack the system, when expressed in units of the estimated age of the universe, is approximately
$\log(\text{Time to Crack}) \approx 66760.5$ .

This means that the time required to crack the system is on the order of $e^{66760.5}$ times the estimated age of the universe ( $4.3 \times 10^{17}$ seconds).

**Note: "Public Key" can not be continous data as it will open up reversal-type attacks. Propose mixing disperate sections of T while also mapping integers,

jconorgrogan/Chaotic-Phasors-Encryption