Data Processing

Technical documentation of how the 128x128 Anna Matrix was compiled from bot replies and prepared for analysis.

Data Processing Framework

Overview

This section documents the data extraction, transformation, and preparation processes used to analyze the Qubic-Bitcoin connection. The framework ensures data integrity while enabling comprehensive statistical analysis.

Data Sources

Source 1: Bitcoin Blockchain

Extraction Parameters:

Parameter	Value
Block range	0 - 50,000
Data type	Coinbase transactions
Fields extracted	Height, timestamp, pubkey, nonce
Total blocks	50,000
Patoshi blocks	~22,000

Extraction Process:

def extract_coinbase_data(block_height):
    """
    Extract coinbase transaction data from block.
 
    Returns:
        dict: {
            'height': int,
            'timestamp': int,
            'pubkey': str (hex),
            'nonce': int,
            'is_patoshi': bool
        }
    """
    block = rpc.getblock(rpc.getblockhash(block_height), 2)
    coinbase_tx = block['tx'][0]
 
    return {
        'height': block_height,
        'timestamp': block['time'],
        'pubkey': extract_pubkey(coinbase_tx),
        'nonce': block['nonce'],
        'is_patoshi': check_patoshi_pattern(block['nonce'])
    }

Source 2: The Anna Matrix (bot replies)

How the matrix was compiled:

The Anna Matrix is a 128×128 table of signed bytes that our team compiled by hand from replies of the @anna_aigarth bot on X. The bot answered queries of the form x+y=? for x and y between -64 and 63. The cell for a query is row 63 - y, column x + 64. The table records the answers of Qubic's Anna bot rather than a file from Qubic's source code, and it contains a few runs of very likely data entry errors (see September 2026 re-check).

Parameter	Value
Dimensions	128 × 128
Data type	int8 (signed byte)
Value range	-128 to +127
Total cells	16,384

Storage Format:

{
  "matrix": [
    [row_0_values...],
    [row_1_values...],
    ...
    [row_127_values...]
  ],
  "dimensions": {
    "rows": 128,
    "cols": 128
  },
  "checksum": "sha256_hash"
}

Source 3: Dead Key Database

Structure:

{
  "total_dead_blocks": 53,
  "all_blocks": [
    {
      "block": 179,
      "dead_pos": 51,
      "pubkey": "04..."
    },
    ...
  ],
  "clusters": [[2411, 2476], [9821, 9871], ...],
  "divisibility": {
    "27": 4,
    "7": 9,
    "4": 9
  }
}

Data Transformation Pipeline

Stage 1: Raw Data Extraction

Bitcoin Node → RPC Calls → JSON Responses → Raw Dataset

Output: raw_blocks.jsonl (one JSON object per line)

Stage 2: Filtering and Classification

def filter_patoshi_blocks(raw_blocks):
    """
    Filter blocks matching Patoshi mining pattern.
 
    Criteria:
    - Nonce within specific ranges
    - Consistent timing patterns
    - Known pubkey characteristics
    """
    patoshi_blocks = []
    for block in raw_blocks:
        if is_patoshi_nonce(block['nonce']):
            patoshi_blocks.append(block)
    return patoshi_blocks

Output: patoshi_blocks.csv (22,190 entries)

Stage 3: Feature Extraction

Extracted Features:

Feature	Description	Type
`block_height`	Block number	int
`timestamp`	Unix timestamp	int
`pubkey`	Compressed public key	str
`dead_pos`	Position of "dead" in pubkey	int or null
`div_27`	Height divisible by 27	bool
`div_43`	Height divisible by 43	bool

Stage 4: Matrix Coordinate Mapping

Multiple mapping functions tested:

Function A: Direct Modulo

def map_direct(block_height):
    row = block_height % 128
    col = (block_height // 128) % 128
    return row, col

Function B: Divisor-Based

def map_divisor(block_height, divisor=27):
    row = (block_height // divisor) % 128
    col = block_height % 128
    return row, col

Function C: Hash-Derived

def map_hash(block_height):
    h = hashlib.sha256(str(block_height).encode()).digest()
    row = h[0] % 128
    col = h[1] % 128
    return row, col

Matrix Analysis Procedures

Procedure 1: Statistical Characterization

def characterize_matrix(matrix):
    """
    Calculate comprehensive statistics for matrix.
    """
    flat = np.array(matrix).flatten()
 
    return {
        'min': np.min(flat),
        'max': np.max(flat),
        'mean': np.mean(flat),
        'median': np.median(flat),
        'std': np.std(flat),
        'positive_count': np.sum(flat > 0),
        'negative_count': np.sum(flat < 0),
        'zero_count': np.sum(flat == 0)
    }

Results:

Statistic	Value
Minimum	-128
Maximum	127
Mean	-0.23
Median	0
Std Dev	71.2
Positive cells	7,891
Negative cells	8,142
Zero cells	351

Procedure 2: Helix Pattern Detection

def find_helix_patterns(matrix):
    """
    Identify triplets where (a + b + c) mod 3 = 0.
    """
    patterns = []
    for row in range(128):
        for col in range(126):
            a, b, c = matrix[row][col], matrix[row][col+1], matrix[row][col+2]
            if (a + b + c) % 3 == 0:
                patterns.append({
                    'row': row,
                    'col': col,
                    'values': (a, b, c),
                    'sum': a + b + c
                })
    return patterns

Results:

Expected patterns (random): ~5,400
Observed patterns: 26,562
Excess ratio: 4.9x

Procedure 3: Diagonal Analysis

def analyze_diagonal(matrix):
    """
    Extract and analyze main diagonal.
    """
    diagonal = [matrix[i][i] for i in range(128)]
 
    return {
        'values': diagonal,
        'sum': sum(diagonal),
        'sum_mod_121': sum(diagonal) % 121,
        'sum_mod_43': sum(diagonal) % 43
    }

Results:

Diagonal sum: 137
Sum mod 121: 16
Sum mod 43: 8

Quality Assurance

Data Validation Checks

Check	Method	Status
Matrix dimensions	Assert 128×128	Passed
Value range	Assert -128 to 127	Passed
Checksum	SHA256 comparison	Passed
Block count	Cross-reference	Passed

Integrity Verification

def verify_matrix_integrity(matrix, expected_checksum):
    """
    Verify matrix data integrity via checksum.
    """
    matrix_bytes = json.dumps(matrix, sort_keys=True).encode()
    actual_checksum = hashlib.sha256(matrix_bytes).hexdigest()
    return actual_checksum == expected_checksum

Output Datasets

Primary Outputs

Dataset	Format	Records	Size
Anna Matrix	JSON	16,384	130 KB
Patoshi Blocks	CSV	22,190	3.2 MB
Dead Blocks	JSON	53	12 KB
Correlation Results	JSON	Variable	~500 KB

Derived Outputs

Dataset	Description
`helix_patterns.json`	All identified Helix patterns
`block_mappings.json`	Block-to-matrix coordinate mappings
`statistical_tests.json`	Chi-squared and other test results
`probability_calculations.json`	Combined probability computations

Reproducibility Instructions

Environment Setup

# Required: Python 3.11+, Bitcoin Core 24.0+
# Create virtual environment
python3.11 -m venv venv
source venv/bin/activate
 
# Install exact dependencies
pip install numpy==1.24.3 pandas==2.0.3 scipy==1.10.1 matplotlib==3.7.2
 
# Verify versions
python --version  # Should output: Python 3.11.x
pip list | grep -E "numpy|pandas|scipy"

Data Sources and Checksums

Dataset	Source	SHA256 Checksum
Anna Matrix	Public matrix file `anna-matrix.json` (hand-compiled bot replies)	`[compute fresh]`
Patoshi Blocks	Block explorer API	`[compute fresh]`
Pre-Genesis Hash	BTC node archive	`000006b15d1327d67e971d1de9116bd60a3a01556c91b6ebaa416ebc0cfaa646`

Exact Replication Commands

# Step 1: Extract Bitcoin data (requires synced node)
bitcoin-cli getblock $(bitcoin-cli getblockhash 0) 2 > block_0.json
# Repeat for blocks 0-50000
 
# Step 2: Verify Pre-Genesis timestamp
echo "1221069728 % 121" | bc  # Should output: 43
 
# Step 3: Load the Anna Matrix
# Use the public matrix file anna_matrix.json (hand-compiled from bot replies,
# not extracted from Qubic source code)
 
# Step 4: Run analysis
python scripts/verify_mod121.py --timestamp 1221069728 --divisor 121
python scripts/chi_squared_test.py --data dead_blocks.json --bins 10

Random Seeds and Parameters

For reproducibility, all random operations use:

Parameter	Value	Rationale
Random seed	42	Standard reproducibility seed
Chi-squared bins	10	Standard for n=53 observations
Significance level	0.05	Standard α threshold

Independent Verification Checklist

# Minimum verification (< 5 minutes)
□ Compute: 1221069728 % 121  → must equal 43
□ Verify: Dead blocks count = 53 in first 50,000 blocks
□ Confirm: Matrix dimensions = 128 × 128
 
# Full verification (requires Bitcoin node)
□ Extract all Patoshi blocks using nonce pattern
□ Map block heights to matrix coordinates
□ Compute cell sums for 27-divisible blocks
□ Run chi-squared test on block distribution

Conclusion

The data processing framework establishes a rigorous pipeline from raw blockchain data to analyzed correlations. All transformations are documented, reproducible, and subject to integrity verification.

The processed datasets form the foundation for the evidence presented in subsequent sections of this documentation.

Edit this page on GitHub Start a discussion on GitHub

Introduction

Start Here

Methods

Anna Matrix

Anna.exe & Aigarth

Bitcoin Data

Sources & Reference

Discussion

Appendices

Data Processing

Data Processing Framework

Overview

Data Sources

Source 1: Bitcoin Blockchain

Source 2: The Anna Matrix (bot replies)

Source 3: Dead Key Database

Data Transformation Pipeline

Stage 1: Raw Data Extraction

Stage 2: Filtering and Classification

Stage 3: Feature Extraction

Stage 4: Matrix Coordinate Mapping

Matrix Analysis Procedures

Procedure 1: Statistical Characterization

Procedure 2: Helix Pattern Detection

Procedure 3: Diagonal Analysis

Quality Assurance

Data Validation Checks

Integrity Verification

Output Datasets

Primary Outputs

Derived Outputs

Reproducibility Instructions

Environment Setup

Data Sources and Checksums

Exact Replication Commands

Random Seeds and Parameters

Independent Verification Checklist

Conclusion