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 times the estimated age of the universe (
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:
For all 40 phasors, the total complexity becomes:
Collision Events
The number of distinct collision pairs is .
Assuming a set number of collisions (10,000), the complexity due to collision events is:
Total Complexity
The total complexity of the system is given by:
Logarithmically, this is expressed as:
Time to Crack
Using Fugaku's computational power of FLOP/s, the logarithmic time required to crack the system is:
The logarithmic time required to crack the system, when expressed in units of the estimated age of the universe, is approximately
.
This means that the time required to crack the system is on the order of times the estimated age of the universe (
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,