Aṇu Astra Integration Guide

Welcome to the official developer documentation for Aṇu Astra. This guide comprehensively covers the integration of our 1024-Qubit Virtual Quantum Processor (VQP) into your enterprise logic.

Aṇu Astra operates exclusively over standard REST APIs, allowing developers to inject Quantum Randomness (QRNG), execute deep-shallowed Quantum Circuits (OpenQASM/JSON), and generate Post-Quantum Cryptographic keys (Kyber/Dilithium) without requiring specialized client-side hardware or cryogenic cooling systems.

Security & Authentication

Every request to the Aṇu Astra API cluster must be cryptographically authenticated using an API Key. You can generate and rotate your keys within the Developer Dashboard.

Quantum Circuit Execution

The Aṇu Astra cluster supports highly complex unitary evolution algorithms on our 1024-qubit Virtual Quantum Processor (VQP). Below is the mathematically rigorous dictionary of physical gates supported by the engine.

Quantum Hello World (Bell State)

Generating perfect entanglement between two qubits in just two operations. This is the industry-standard benchmark for hardware verification.

from anuastra import Client, QuantumCircuit

astra = Client(api_key='your_sk_live_key')
qc = QuantumCircuit(2)

# Generate a Bell State: |Φ⁺⟩ = (|00⟩ + |11⟩) / √2
qc.h(0)           # Create superposition on Qubit 0
qc.cx(0, 1)       # Entangle Qubit 0 with Qubit 1

result = astra.execute_quantum(qc, shots=1024)
print("Bell State Counts:", result['results']['counts'])

const { AṇuAstra, QuantumCircuit } = require('anuastra');
const astra = new AṇuAstra({ apiKey: 'your_sk_live_key' });

const qc = new QuantumCircuit(2);
qc.h(0).cx(0, 1); // Fluent entanglement

const res = await astra.quantum.execute(qc, { shots: 1024 });

curl -X POST "https://astra.cryptopix.in/api/v1/quantum/execute" \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "qubits": 2,
    "circuit": [
      { "gate": "H", "target": [0] },
      { "gate": "CX", "target": [0, 1] }
    ]
  }'

OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
h q[0];
cx q[0], q[1];

Execution Telemetry & Response Schema

Every successful execution on the Aṇu Astra cluster returns a strongly-typed JSON envelope containing both computational results and cryptographic audit telemetry.

{
  "status": "success",
  "data": {
    "execution_time_ms": 124,              // Simulation overhead in milliseconds
    "engine": "vqp-feynman-integral",       // Astra Core identification
    "num_qubits": 2,                       // Allocated hardware resources
    "results": {
      "counts": { "00": 512, "11": 512 },  // Raw measurable state frequencies
      "probabilities": { "00": 0.5, "11": 0.5 } // Born-rule statistical weights
    },
    "cost": 10,                            // Consumed Quantum Credits
    "remaining_credits": 9850              // Updated wallet balance
  },
  "metadata": {
    "transaction_id": "circ-req-uuid-...", // Audit trail identifier
    "generated_at": "2026-04-06T21:58Z"    // Chronological server time
  },
  "compliance": {
    "signature": "ed25519_sig_hex...",     // Digital proof of result integrity
    "verification_url": "https://..."      // Public verification endpoint
  }
}

Industrial Portability: QASM Export

For research archival and peer-review, Aṇu Astra supports the Bridge Pattern—allowing you to build circuits natively and export them to OpenQASM 2.0 strings for cross-platform verification.

from anuastra import QuantumCircuit

# 1. Build natively via SDK Builder
qc = QuantumCircuit(3)
qc.h(0).cx(0, 1).cx(1, 2)

# 2. Export to Industry-Standard QASM String
qasm_output = qc.to_qasm()
print(qasm_output)

# Expected Output:
# OPENQASM 2.0;
# include "qelib1.inc";
# qreg q[3];
# h q[0];
# cx q[0], q[1];
# cx q[1], q[2];

Post-Quantum Cryptography (PQC)

Traditional RSA and ECC encryption schemes are mathematically vulnerable to Shor's Algorithm executed on mature Quantum Computers. Aṇu Astra provides immediate FIPS 203 & 204 compliant drops-ins for Post-Quantum generation architectures.

import requests

payload = {
    "algorithm": "kyber",          # 'kyber' (KEM) or 'dilithium' (DSA)
    "security_level": 768          # Equivalencies: 512, 768, 1024
}

response = requests.post(
    "https://astra.cryptopix.in/api/v1/quantum/pqc/keygen",
    json=payload,
    headers={"Authorization": "Bearer sk_live_xxx"}
)

keys = response.json()["data"]
print("Public Key:", keys["public_key"])

curl -X POST "https://astra.cryptopix.in/api/v1/quantum/pqc/keygen" \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "algorithm": "kyber",
    "security_level": 768
  }'

Telemetry & Error Handling

Aṇu Astra returns standard JSON envelopes. On failure, status will be mapped to "error".

Quantum Random Number Generation (QRNG)

The cornerstone of unconditional cryptographic security is perfect entropy. Traditional PRNGs (Pseudo-Random Number Generators) rely on deterministic algorithms (like Mersenne Twister) which are theoretically predictable if the seed state is compromised or reverse-engineered.

Aṇu Astra's QRNG harnesses simulated superposition collapse. By placing a virtual qubit array into perfect superposition |ψ⟩ = (1/√2)(|0⟩ + |1⟩) and forcing an immediate measurement over entire blocks concurrently, we extract high bit-rate, theoretically perfect minimum entropy (H_min ≈ 7.99 bits/byte) that is non-deterministic and cryptographically flawless.

QRNG REST Endpoints

Retrieve raw entropy across multiple data structures using exactly one master endpoint.

QRNG Implementation Examples

Using the official Aṇu Astra Native SDKs is the recommended pattern for production.

from anuastra import Client

astra = Client(api_key='sk_live_YourAstraKeyHere')

# Native Python wrappers cleanly format API telemetry under the hood
hex_seed = astra.qrng.get_random_bytes(length=32)
unbiased_int = astra.qrng.get_random_int(min=100, max=1000)
pure_float = astra.qrng.get_random_float()
bit_string = astra.qrng.get_random_bits(size=256)

print("Hexadecimal Seed:", hex_seed['entropy'])
print("Float Probability [0,1):", pure_float['entropy'])

import { AṇuAstra } from 'anuastra';

const astra = new AṇuAstra({ apiKey: 'sk_live_YourAstraKeyHere' });

async function generateEntropy() {
    // Strictly typed Promises for all QRNG forms
    const byteRes = await astra.qrng.getRandomBytes(64);
    const bitsRes = await astra.qrng.getRandomBits(1024);
    const intRes = await astra.qrng.getRandomInt(1, 10);
    const fRes = await astra.qrng.getRandomFloat();

    console.log(`Quantum Coin Toss: ${intRes.data.entropy === 1 ? 'Heads' : 'Tails'}`);
}

curl -X POST "https://astra.cryptopix.in/api/v1/quantum/qrng" \
  -H "Authorization: Bearer sk_live_YourAstraKey" \
  -H "Content-Type: application/json" \
  -d '{"type": "float"}'