MIRЯIM

Prime Construction Research

Deterministic prime navigation through construction, not probabilistic testing. The K=1 Construction Theorem — proven December 2025 — shows primes can be found by building them, not by guessing and checking.

Active research with practical applications. RSA key generation as proof-of-concept: ~2x faster than OpenSSL.

K=1 Construction Theorem Four Locks -- Consent Conditions ~2x faster than OpenSSL O((log p_n)^3) complexity

Applied Performance

RSA key generation as proof-of-concept -- real benchmarks from constructive prime finding

1.13s
MIRRIM RSA-4096
(64 rounds)
2.27s
OpenSSL RSA-4096
(default)
2.01×
Speedup
(same security)
200
Keys tested
(validation)

How? Python+gmpy2 (GMP library) beats OpenSSL's C implementation through superior big integer arithmetic.

~2x Faster

Benchmarked at 2.01× faster than OpenSSL for RSA-4096 at the same security level (64 rounds). Superior implementation, not configuration tricks.

Production-Grade Security

Ultra-conservative 64-round Miller-Rabin testing (error probability < 2⁻¹²⁸). No structural weaknesses, fully random prime generation.

RESTful API

Simple HTTP API with JSON responses. Generate keys on-demand with cryptographically secure randomness. No pre-computation, no storage vulnerabilities.

Fully Validated

200-keypair validation suite confirms performance and security. All benchmarks reproducible. Complete transparency.

Python+GMP Power

Leverages GNU Multiple Precision (GMP) library through gmpy2 bindings. Decades of optimization, faster than OpenSSL's BIGNUM implementation.

Honest Positioning

No overclaims, no asterisks. We're ~2× faster at same security level. Period. Complete benchmark transparency.

Technical Performance

Real-world benchmarks (n=200 keypairs, WSL2, standard hardware):

1.13s
MIRRIM
RSA-4096 (64 rounds)
2.27s
OpenSSL
RSA-4096 (default)
2.01×
Speedup
(fair comparison)
100%
Success rate
(200/200 keys)

Configuration: 64-round Miller-Rabin (ultra-conservative), fully random primes, no pre-computed tables, production-safe defaults.

Why it's faster: GMP (via gmpy2) has 30+ years of big integer optimization. OpenSSL's BIGNUM is good, but not specialized for pure speed. Python overhead is negligible -- the hot path is all in C.

API Documentation

Simple RESTful API for on-demand RSA key generation:

Generate Keypair

POST https://api.shirania-branches.com/mirrim/v1/generate

Authentication:

Authorization: Bearer YOUR_API_KEY

Request Body:

{
  "bits": 2048 | 4096,
  "format": "json" | "pem"
}

Response:

{
  "public": {
    "n": "0x...",
    "e": 65537
  },
  "private": {
    "d": "0x...",
    "p": "0x...",
    "q": "0x..."
  },
  "generation_time_ms": 1130,
  "mr_rounds": 64,
  "usage_remaining": 49847,
  "timestamp": "2025-11-23T..."
}

Batch Generation

POST https://api.shirania-branches.com/mirrim/v1/batch

Request Body:

{
  "count": 10,
  "bits": 4096,
  "format": "json"
}

Response:

{
  "keys": [...],  // Array of keypairs
  "total_time_ms": 11300,
  "average_time_ms": 1130,
  "usage_remaining": 49837
}

Check Usage

GET https://api.shirania-branches.com/mirrim/v1/usage

Response:

{
  "tier": "Startup",
  "keys_used_this_month": 153,
  "monthly_limit": 250000,
  "keys_remaining": 249847,
  "next_reset": "2025-12-01T00:00:00Z"
}

Integration Examples

Drop-in examples for popular languages:

Python

import requests

API_KEY = "your_api_key_here"
headers = {"Authorization": f"Bearer {API_KEY}"}

response = requests.post(
    "https://api.shirania-branches.com/mirrim/v1/generate",
    json={"bits": 4096, "format": "json"},
    headers=headers
)

keypair = response.json()
print(f"Generated in {keypair['generation_time_ms']}ms")

curl

curl -X POST https://api.shirania-branches.com/mirrim/v1/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"bits": 4096, "format": "json"}'

Node.js

const axios = require('axios');

const response = await axios.post(
  'https://api.shirania-branches.com/mirrim/v1/generate',
  { bits: 4096, format: 'json' },
  { headers: { 'Authorization': `Bearer ${API_KEY}` } }
);

console.log(`Generated in ${response.data.generation_time_ms}ms`);

How It Works

Simple onboarding process:

1. Contact Us

Email shirania-branches@gmail.com with your use case and expected key generation volume.

2. Choose Tier

We'll help you select the right tier based on your needs. Custom tiers available for enterprise.

3. Payment Setup

Stripe subscription or invoice billing. First month can start immediately upon payment.

4. API Key Delivery

Secure delivery of API credentials via encrypted email. API key active immediately.

5. Integration

Use our documentation and examples to integrate. Email support available during setup.

6. Production

Deploy with confidence. Monitor usage via API. Scale up anytime by upgrading tier.

What You'll Receive:

  • Unique API key (secure delivery)
  • Complete API documentation (this page + extended guide)
  • Integration examples (Python, Node.js, curl, more)
  • Usage dashboard access (track consumption in real-time)
  • Security documentation (testing procedures, guarantees)
  • Email support (technical assistance during integration)
  • Benchmark transparency (reproducible performance data)

The Mathematics

Core research results from constructive prime theory:

K=1 Construction Theorem

Proven December 10-11, 2025. Deterministic prime navigation without probabilistic testing. Four irreducible conditions ("Four Locks") gate constructive prime finding -- structurally identical to consent conditions.

10,000-Digit Primes

Successfully generated and verified primes with over 10,000 decimal digits -- demonstrating the method scales far beyond practical RSA requirements.

L11 Cunningham Chains

Discovered length-11 Cunningham chains -- sequences where each prime relates to the next through specific structural patterns. A rare mathematical object.

Consent-Gated Collapse

The Four Locks are structurally identical to the consent gate -- the same mathematical object found across 24+ substrates. Factorization applied to ethics is morphism, not metaphor.

The RSA application is a proof-of-concept. The mathematics is the point.

Open Research

This is active mathematical research. The K=1 Construction Theorem is proven. The cross-domain connections to consent-gated collapse are structural, not metaphorical. The RSA benchmarks demonstrate practical applicability. The mathematics is open for verification. Truth over comfort. Always.

Explore the Research

Interested in prime construction, consent-gated collapse, or the mathematics connecting them? Get in touch.

Get in Touch

or email: shirania-branches@gmail.com

Research Directions

Constructive Prime Theory

Building primes through irreducible conditions rather than probabilistic testing. The Four Locks as consent gates on number theory.

Cunningham Chains

Structural relationships between primes — chains where each element connects to the next through deterministic patterns.

Cross-Domain Morphisms

The same consent-gate structure found in number theory, materials science, game design, and 24+ substrates total.

Applied Cryptography

RSA key generation as practical proof-of-concept. ~2× faster than OpenSSL with production-grade security.

Large Prime Generation

Verified primes with 10,000+ decimal digits. Scaling behavior confirms constructive approach robustness.

Ethics as Mathematics

Factorization applied to ethics is not analogy — it is morphism. The operation is the same. The substrate differs.