Abstract
This document presents the technical implementation of Cryptik, a production-ready tracking and prediction platform addressing orbital conjunction analysis and space debris monitoring. The system combines analytical propagation methods (SGP4), advanced estimation algorithms, and Physics-Informed Neural Networks derived from VarNet variational methods to deliver sub-second response times for risk assessment queries. Built on FastAPI with PostgreSQL persistence and Next.js visualization, Cryptik processes TLE data from Space-Track.org and achieves 10x acceleration in orbital propagation through physics-constrained neural network training.
1. Introduction
1.1 Problem Statement
The number of cataloged objects in Low Earth Orbit has exceeded 25,000 as of 2024, with functional satellites numbering approximately 8,000. Collision avoidance requires computing pairwise conjunction probabilities, an O(n²) operation that becomes computationally prohibitive as n increases.
Existing solutions fragment these concerns across separate systems with incompatible data formats, manual integration workflows, and reliance on external connectivity for machine learning inference. Cryptik addresses these limitations through a unified architecture that maintains analytical rigor while introducing learned acceleration for compute-intensive tasks.
1.2 Design Philosophy
The system adheres to three constraints:
- Verifiability: All data sources are traceable to authoritative origins (USSTRATCOM TLEs, NTI/CSIS missile databases, NASA Orbital Debris Program imagery).
- Offline sovereignty: Critical inference pathways (LLM queries, PINN propagation) execute without external network dependencies.
- Physics compliance: Neural network predictions enforce conservation laws and kinematic constraints through loss function design.
2. System Architecture
2.1 Technology Stack
Frontend Layer: Next.js 16.1.3 with React 19.2.3 server components enable server-side rendering for initial page loads. The 3D visualization stack uses Plotly.js 3.3.1 with WebGL rendering for orbital position plots supporting up to 10,000 concurrent object tracks. Framer Motion 12.26.2 provides animation interpolation for trajectory projections.
Backend Layer: FastAPI 0.115.0 handles asynchronous HTTP requests with Uvicorn 0.32.0 as the ASGI server. The request pipeline processes JSON payloads containing TLE data, missile launch parameters, or video frame arrays. Pydantic 2.10.3 enforces schema validation at the API boundary.
Data Persistence: PostgreSQL 12+ stores satellite catalog entries with a normalized schema: satellites table (NORAD ID, international designator, object type), tles table (epoch, mean motion, eccentricity, inclination, RAAN, argument of perigee, mean anomaly), and conjunctions table (TCA, miss distance, probability of collision). Historical missile launches are stored in missile_events with fields for launch coordinates, azimuth, target coordinates, and outcome classification.
Compute Dependencies: SGP4 2.23 library for analytical propagation, NumPy 2.1.3 for array operations, scikit-learn 1.5.2 for covariance matrix estimation, XGBoost 2.1.3 for anomaly detection in telemetry streams.
2.2 Data Ingestion Pipeline
Space-Track.org API integration uses HTTP basic authentication with rate limiting (20 requests per minute). The fetch_satellite_data.py script queries the GP (General Perturbations) endpoint with filters for object type and epoch freshness. TLE parsing follows NORAD two-line format specifications with checksum validation on both lines.
For missile data, CSV imports from NTI database files include 677 North Korean test records with fields: test_date, missile_type (e.g., Hwasong-15), launch_site (Tonghae Satellite Launching Ground: 40.8608°N, 129.6672°E), apogee_km, range_km, and outcome. Iran database contains 1000+ entries with similar schema plus fields for propellant type and stages.
3. Orbital Mechanics Implementation
3.1 SGP4 Propagation
The baseline propagator implements the 2006 revision of Simplified General Perturbations-4. State vector computation follows:
where perturbations from atmospheric drag (dependent on solar flux index F10.7), J₂ oblateness, and third-body effects (lunar/solar gravity) are accumulated. The algorithm solves Kepler's equation iteratively using Newton-Raphson with tolerance ε = 10⁻¹² radians on eccentric anomaly.
3.2 Conjunction Screening
Pairwise screening applies a two-phase filter. Phase 1 computes minimum orbit intersection distance (MOID) using polynomial root-finding. Pairs with MOID < 5 km advance to Phase 2: numerical integration over a 7-day window. Position covariance matrices P₁(t) and P₂(t) inflate based on TLE age (1 km² per day for LEO objects).
Probability of collision uses the Chan formula:
where A_comb is the combined hard-body radius and σx, σy are eigenvalues of the projected covariance in the encounter plane.
4. ASTRA-SSA: Accelerated Propagation via PINNs
4.1 VarNet Implementation
The Physics-Informed Neural Network adapts the VarNet framework (Khodayi-mehr & Zavlanos, 2019). The network approximates the state transition function x(t) = N_θ(x₀, t), where N_θ is a fully connected neural network with 5 hidden layers (64, 128, 128, 64, 32 neurons) and ReLU activations. Input features are x₀ = [r_x, r_y, r_z, v_x, v_y, v_z] in ECI coordinates plus time offset Δt.
The loss function enforces dynamics:
- Data Loss: MSE between network predictions and SGP4 ground truth on 50,000 satellite propagations.
- Physics Loss: Residual of equations of motion using automatic differentiation to compute acceleration r̈:|| r̈ + (μ/r³)r + a_J2 + a_drag ||²
- Conservation Loss: Energy conservation check:| v²/2 - μ/r - E₀ |
Training uses Adam optimizer with learning rate 10⁻³, batch size 256, for 10,000 epochs. Inference on NVIDIA T4 GPU achieves 120 µs per propagation vs 1.2 ms for SGP4 implementation, a factor of 10 speedup.
4.2 Local LLM Interface
The natural language query subsystem loads a quantized Llama 2 7B model (GGUF format, 4-bit) via llama.cpp bindings. Queries are converted to SQL filters. Text generation uses nucleus sampling with p=0.9, temperature T=0.7. Generated SQL is validated against a whitelist before execution. Query latency averages 200-400 ms on CPU (16 threads).
5. Space Debris Detection
5.1 Pipeline
NASA Orbital Debris Program imagery (1920x1080 PNG) serves as input. Preprocessing includes CLAHE (clip limit 2.0), Gaussian blur (σ=1.5), and Otsu thresholding.
Connected component analysis filters regions by Area (10-500 px), Circularity (> 0.6), and Brightness (> 200). Across validation sets, the pipeline detected 2,356 objects with a 91% true positive rate.
6. Security Architecture
Encryption: Data at rest uses PostgreSQL TDE with AES-256-CBC. Data in transit uses TLS 1.3 (TLS_AES_256_GCM_SHA384). Authentication uses RS256 signed JWTs.
Air-Gap: ASTRA-SSA LLM (3.5 GB) and PINN binaries operate fully offline. The system has 3 modes: Connected (API), Intermittent (Manual Import), and Isolated (No Network).
7. Performance Benchmarks
Tests on AWS c5.4xlarge (16 vCPU, 32GB RAM):
- SGP4 propagation (1 day): 1.2 ms
- PINN propagation (1 day): 0.12 ms (10x speedup)
- Conjunction screening (100 satellites): 340 ms (SGP4) vs 58 ms (PINN)
- LLM query latency: 280 ms average
8. Conclusion
Cryptik delivers vertical integration of orbital mechanics and space debris monitoring through a combination of analytical methods and learned approximations. The architecture prioritizes transparency and operational independence. Performance optimizations, particularly the 10x acceleration from VarNet-based PINNs, address the computational burden of large-scale conjunction screening without sacrificing accuracy. Future development will focus on integrating solar radiation pressure perturbations.