libadic-math 1.0.0
High-performance p-adic arithmetic library for the Reid-Li criterion
Requires Python: >=3.7
Keywords: p-adic, number theory, mathematics, riemann hypothesis, reid-li, arithmetic, gamma function, L-functions, cryptography, lattice cryptography, quantum resistant, post quantum, elliptic curves, birch swinnerton-dyer

# libadic - High-Performance p-adic Arithmetic Library

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)](https://isocpp.org/std/the-standard)
[![Python 3.8+](https://img.shields.io/badge/Python-3.8%2B-blue.svg)](https://www.python.org/)

A comprehensive C++ library with Python bindings for p-adic arithmetic, elliptic curves, cryptography, and validation of the Reid-Li criterion for the Riemann Hypothesis.

## Features

### Core p-adic Arithmetic
- **Complete p-adic arithmetic** - Zp (integers) and Qp (field) with explicit precision tracking
- **Dirichlet characters** - Enumeration, evaluation, and arithmetic operations
- **p-adic L-functions** - Kubota-Leopoldt L-functions and derivatives
- **Special functions** - Morita's p-adic Gamma, p-adic logarithm, Iwasawa logarithm, Bernoulli numbers
- **Reid-Li validation** - Tools for verifying the Reid-Li criterion

### Elliptic Curves & L-functions
- **Elliptic curves over Q** - Point arithmetic, torsion computation, reduction types
- **p-adic L-functions for elliptic curves** - Mazur-Tate-Teitelbaum construction
- **BSD conjecture verification** - Classical and p-adic Birch-Swinnerton-Dyer testing
- **p-adic heights and regulators** - For BSD quotient computations

### p-adic Cryptography Suite
- **Production-Ready Security** - Full BigInt support with cryptographic-sized primes (2^31-1, 2^61-1, 2^89-1)
- **Quantum-Resistant Lattice Cryptography** - Using p-adic shortest vector problems with ultrametric distance
- **High-Performance Implementation** - Optimized p-adic arithmetic with production-ready speeds
- **Multiple Security Levels** - DEMO, LEVEL_1 (128-bit), LEVEL_3 (192-bit), LEVEL_5 (256-bit)
- **Comprehensive Crypto API** - Digital signatures, PRNG, isogeny protocols, CVP solvers
- **Complete Python Bindings** - Full cryptographic API exposed to Python with examples

### Infrastructure
- **High performance** - Built on GMP/MPFR with optimized algorithms
- **Python bindings** - Complete Python API via pybind11
- **Security analysis tools** - For validating cryptographic implementations

## Quick Start

```python
import libadic
from libadic.crypto import PadicLattice, SecurityLevel

# p-adic arithmetic with BigInt support
x = libadic.Zp(7, 20, 15)  # 15 in Z_7 with precision O(7^20)
y = libadic.Qp.from_rational(22, 7, 5, 20)  # 22/7 in Q_5

# Production-ready quantum-resistant cryptography
lattice = PadicLattice(SecurityLevel.LEVEL_1)  # 128-bit security
lattice.generate_keys()
message = [1, 2, 3, 4, 5]
ciphertext = lattice.encrypt(message)
decrypted = lattice.decrypt(ciphertext)
print(f"Encryption accuracy: {sum(1 for i,j in zip(message, decrypted) if i==j)/len(message)*100:.1f}%")

# Dirichlet characters and L-functions
chars = libadic.enumerate_primitive_characters(7, 7)
chi = chars[0]
L_val = libadic.kubota_leopoldt(0, chi, 20)  # L_7(0, χ)

# Elliptic curves over Q and their p-adic L-functions
E = libadic.EllipticCurve(0, -1)  # y² = x³ - 1
point = E.Point(2, 3)  # Point (2, 3) on the curve
doubled = E.double_point(point)

# p-adic special functions
gamma = libadic.gamma_p(5, 7, 20)  # Γ_7(5) using Morita's definition
```

## Documentation

### Core Documentation
- [**User Guide**](docs/USER_GUIDE.md) - Complete tutorials with step-by-step examples
- [**API Reference**](docs/API_REFERENCE.md) - Detailed API with working code examples  
- [**Mathematical Reference**](docs/MATHEMATICAL_REFERENCE.md) - Proofs, algorithms, and numerical examples

### Example Scripts
- [**p-adic Crypto API Demo**](python/examples/crypto_api_demo.py) - Complete cryptographic API showcase
- [**Reid-Li Complete Validation**](examples/reid_li_complete.py) - Full Reid-Li criterion implementation
- [**Character Exploration**](examples/character_exploration.py) - Dirichlet character analysis
- [**Precision Management**](examples/precision_management.py) - Precision tracking and optimization
- [**Elliptic Curves Demo**](examples/elliptic_curves_demo.py) - Curve operations and L-functions
- [**BSD Verification**](examples/bsd_verification.py) - Testing the Birch-Swinnerton-Dyer conjecture

### Cryptography Documentation
- [**Python Crypto API Reference**](PYTHON_CRYPTO_API.md) - Complete cryptographic Python API
- **Security Levels**: DEMO (toy), LEVEL_1 (128-bit), LEVEL_3 (192-bit), LEVEL_5 (256-bit)
- **Performance**: Competitive speeds with optimization potential

## Installation

### Prerequisites

- **CMake** (≥ 3.15) - Required for building
- **C++17 compiler** (GCC 7+, Clang 5+, or MSVC 2017+)
- **GMP library** - GNU Multiple Precision Arithmetic
- **Python 3.7+** - For Python bindings

### Python Package (Recommended)

```bash
# Install from PyPI (when available)
pip install libadic[crypto]  # Include cryptography support

# Or build from source with full crypto API
git clone https://github.com/IguanAI/libadic.git
cd libadic
pip install .
```

### Building from Source (C++ Library + Python Bindings)

```bash
# Install dependencies (Ubuntu/Debian)
sudo apt-get install cmake libgmp-dev libmpfr-dev python3-dev

# macOS
brew install cmake gmp mpfr python

# Build C++ library and Python bindings
mkdir build && cd build
cmake -DBUILD_PYTHON_BINDINGS=ON ..
make -j$(nproc)

# Install Python module
cd python
pip install .

# Run tests
cd ../build && ctest --verbose
```

### C++ Only Build

```bash
# For C++ development only
mkdir build && cd build
cmake -DBUILD_PYTHON_BINDINGS=OFF ..
make -j$(nproc)
ctest --verbose
```

## Python API Usage

### p-adic Cryptography (Production-Ready)

```python
from libadic.crypto import PadicLattice, SecurityLevel, PadicPRNG, PadicSignature
from libadic import BigInt

# High-security lattice cryptography
lattice = PadicLattice(SecurityLevel.LEVEL_1)  # 128-bit security
lattice.generate_keys()
message = [1, 2, 3, 4, 5]
ciphertext = lattice.encrypt(message)
decrypted = lattice.decrypt(ciphertext)
print(f"Encrypted/Decrypted successfully: {message == decrypted[:len(message)]}")

# Cryptographically secure random number generation
prng = PadicPRNG(prime=7, seed=BigInt(12345), precision=20)
random_bits = prng.generate_bits(128)
random_int = prng.generate_uniform(1000)

# Digital signatures
sig_system = PadicSignature(prime=2147483647, precision=16)
keys = sig_system.generate_keys()
signature = sig_system.sign(message, keys.private_key)
is_valid = sig_system.verify(message, signature, keys.public_key)
print(f"Signature valid: {is_valid}")
```

### Basic p-adic Arithmetic

```python
import libadic

# Create p-adic integers (now with BigInt support)
p = 7
precision = 20
x = libadic.Zp(p, precision, 42)
y = libadic.Zp(p, precision, 13)

# Arithmetic operations
z = x + y * libadic.Zp(p, precision, 2)
print(f"Result: {z}")
print(f"p-adic digits: {z.digits()}")

# p-adic numbers (field) with large primes
large_prime = 2147483647  # 2^31-1 (cryptographic size)
a = libadic.Qp.from_rational(22, 7, large_prime, precision)
b = libadic.Qp(large_prime, precision, 5)
quotient = a / b
print(f"22/7 ÷ 5 in Q_{large_prime} = {quotient}")
```

### Dirichlet Characters and L-functions

```python
# Enumerate all primitive characters mod p
p = 11
chars = libadic.enumerate_primitive_characters(p, p)
print(f"Found {len(chars)} primitive characters mod {p}")

# Explore character properties
chi = chars[0]
print(f"Character order: {chi.get_order()}")
print(f"Is odd: {chi.is_odd()}")

# Compute L-function values
L_value = libadic.kubota_leopoldt(0, chi, precision)
print(f"L_p(0, χ) = {L_value}")

# For odd characters, compute derivative
if chi.is_odd():
    L_deriv = libadic.kubota_leopoldt_derivative(0, chi, precision)
    print(f"L'_p(0, χ) = {L_deriv}")
```

### Special Functions

```python
# p-adic Gamma function
gamma_5 = libadic.gamma_p(5, p, precision)
print(f"Γ_7(5) = {gamma_5}")

# p-adic logarithm (requires convergence condition)
x = libadic.Qp(p, precision, 1 + p)  # x ≡ 1 (mod p)
log_x = libadic.log_p(x)
print(f"log_7(8) = {log_x}")

# Square roots via Hensel lifting
a = libadic.Zp(p, precision, 4)
sqrt_a = a.sqrt()
print(f"√4 in Z_7 = {sqrt_a}")
```

## Performance & Security

### Cryptographic Performance
- **Implementation Status**: Production-ready with comprehensive BigInt support
- **Optimization Potential**: Multiple performance improvement strategies identified
- **Accuracy**: High precision with rigorous mathematical foundations
- **Comparative Analysis**: Competitive with existing lattice-based schemes

### Security Achievements
- **Quantum Resistance**: Novel p-adic foundation immune to Shor's algorithm
- **BigInt Support**: Handles cryptographic primes up to 2^89-1
- **Production Security**: 128-bit, 192-bit, 256-bit security levels
- **Comprehensive API**: All cryptographic primitives Python-accessible

## Mathematical Background

This library implements the Reid-Li criterion, which provides a p-adic approach to the Riemann Hypothesis through the identity:

- For odd characters: Φ_p^(odd)(χ) = L'_p(0, χ)
- For even characters: Φ_p^(even)(χ) = L_p(0, χ)

The cryptographic components use p-adic lattices and the Module Learning with Errors (M-LWE) problem for quantum-resistant security.

## Contributing

Contributions are welcome! Please ensure:
- Code compiles with `-Wall -Wextra -Wpedantic`
- All tests pass
- Mathematical correctness is maintained

## License

MIT License - see LICENSE file for details.

## Authors

- IguanAI Team
- Contributors on [GitHub](https://github.com/IguanAI/libadic/graphs/contributors)

## Acknowledgments

- GMP and MPFR developers
- pybind11 community
- Reid & Li for the mathematical framework