quantumcore-az 0.1.0__py3-none-any.whl

quantumcore_az-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: quantumcore-az
+Version: 0.1.0
+Summary: Quantum-like computing on classical hardware
+Author-email: MAMMADOV ELDAR VAQIF oglu <office@azsec.biz>
+License: Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# QuantumCore-AZ
+
+Quantum-like computing on classical hardware.
+
+## Features
+- 100 qubits
+- 65,535 entanglements
+- Grover's search
+- Lottery search
+- Anti-debug protection
+
+## Installation
+```bash
+pip install quantumcore-az
+
+## Usage
+from quantumlib import Core
+qc = Core()
+qc.show()

quantumcore_az-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+quantumlib/__init__.py,sha256=FT-psl1PYMFbgIezn1PsEjJsDXWeleG4BKft8dgJCKc,196
+quantumlib/_core.cpython-312-x86_64-linux-gnu.so,sha256=S44J18Xfo1tY5ZKqBtOXTjsIuAk721o9IlfakR6BfCk,31488
+quantumlib/wrapper.py,sha256=uTTnQ16wNTSb0V1ZYtHSGdDiLM-y3h7MCSPD3tto2jM,5668
+quantumcore_az-0.1.0.dist-info/METADATA,sha256=HHo7c2gJxEixRyjb_YhFGmqh-TSeMNVGq-FKFD-fOac,635
+quantumcore_az-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quantumcore_az-0.1.0.dist-info/top_level.txt,sha256=6qEJxhfdxiT-hzHUgowH0x7_A2FVA1EAOe-92pEVvt0,11
+quantumcore_az-0.1.0.dist-info/RECORD,,

quantumcore_az-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quantumcore_az-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+quantumlib

quantumlib/__init__.py

@@ -0,0 +1,10 @@
+"""
+QuantumLib - Quantum-like computing on classical hardware
+Developed by MAMMADOV ELDAR VAQIF oglu
+https://www.azsec.biz
+"""
+
+from .wrapper import Core
+
+__version__ = "0.1.0"
+__all__ = ["Core"]

quantumlib/wrapper.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+QuantumLib - Python Wrapper
+Developed by MAMMADOV ELDAR VAQIF oglu
+https://www.azsec.biz
+"""
+
+import ctypes
+import os
+import sys
+import json
+import random
+from typing import List, Tuple, Dict, Any
+
+class Complex(ctypes.Structure):
+    _fields_ = [("real", ctypes.c_double), ("imag", ctypes.c_double)]
+
+class State(ctypes.Structure):
+    _fields_ = [
+        ("state", Complex),
+        ("mask", ctypes.c_uint64 * 1024)
+    ]
+
+class Engine(ctypes.Structure):
+    _fields_ = [
+        ("states", State * 100),
+        ("dimension", ctypes.c_char * 128),
+        ("channels", ctypes.c_uint64),
+        ("protection", ctypes.c_int)
+    ]
+
+class Core:
+    def __init__(self, lib_path: str = None):
+        if lib_path is None:
+            # Определяем путь к папке с пакетом
+            import quantumlib
+            package_dir = os.path.dirname(quantumlib.__file__)
+            
+            # Ищем _core.so в папке пакета
+            local_path = os.path.join(package_dir, "_core.so")
+            
+            # Если не нашли, пробуем варианты
+            if not os.path.exists(local_path):
+                # Для установленного пакета (wheel)
+                wheel_path = os.path.join(package_dir, "_core.cpython-312-x86_64-linux-gnu.so")
+                if os.path.exists(wheel_path):
+                    local_path = wheel_path
+            
+            if not os.path.exists(local_path):
+                raise RuntimeError(
+                    f"Library not found at {local_path}. "
+                    "Please reinstall: pip install --force-reinstall quantumlib"
+                )
+            
+            lib_path = local_path
+
+        try:
+            self.lib = ctypes.CDLL(lib_path)
+        except OSError as e:
+            raise RuntimeError(f"Library load failed: {e}")
+
+        self.lib.init_engine.restype = ctypes.POINTER(Engine)
+        self.lib.free_engine.argtypes = [ctypes.POINTER(Engine)]
+        self.lib.apply_tuning.argtypes = [ctypes.POINTER(Engine), ctypes.c_double]
+        self.lib.display_state.argtypes = [ctypes.POINTER(Engine)]
+        self.lib.check_protection.restype = ctypes.c_int
+        self.lib.check_protection.argtypes = [ctypes.POINTER(Engine)]
+
+        self.engine = self.lib.init_engine()
+        if not self.engine:
+            raise RuntimeError("Engine init failed.")
+
+    def check(self) -> bool:
+        return self.lib.check_protection(self.engine) == 1
+
+    def tune(self, phase: float) -> None:
+        self.lib.apply_tuning(self.engine, phase)
+
+    def show(self) -> None:
+        self.lib.display_state(self.engine)
+
+    def info(self) -> Dict[str, Any]:
+        return {
+            "name": "QuantumLib v1.0",
+            "developer": "MAMMADOV ELDAR VAQIF oglu",
+            "website": "https://www.azsec.biz",
+            "states": 100,
+            "channels": self.engine.contents.channels,
+            "protection": "ACTIVE" if self.engine.contents.protection else "DECOY"
+        }
+
+    def get_state(self, index: int) -> Tuple[float, float]:
+        if index < 0 or index >= 100:
+            raise IndexError("State index must be between 0 and 99")
+        s = self.engine.contents.states[index]
+        return (s.state.real, s.state.imag)
+
+    def get_all_states(self) -> List[Tuple[float, float]]:
+        result = []
+        for i in range(100):
+            s = self.engine.contents.states[i]
+            result.append((s.state.real, s.state.imag))
+        return result
+
+    def get_channels(self) -> int:
+        return self.engine.contents.channels
+
+    def get_dimension(self) -> str:
+        return self.engine.contents.dimension.decode('utf-8')
+
+    def export_states_json(self) -> str:
+        data = {
+            "dimension": self.get_dimension(),
+            "channels": self.get_channels(),
+            "states": self.get_all_states()
+        }
+        return json.dumps(data, indent=2)
+
+    def grover_search(self, target_state: int, iterations: int = 10) -> dict:
+        results = []
+        phase = 0.0
+        initial = self.get_state(target_state)
+        initial_amp = (initial[0]**2 + initial[1]**2)**0.5
+        for i in range(iterations):
+            phase += 0.1
+            self.tune(0.7854)
+            s = self.get_state(target_state)
+            amp = (s[0]**2 + s[1]**2)**0.5
+            results.append({
+                "iteration": i,
+                "amplitude": amp,
+                "phase": phase
+            })
+        return {
+            "target": target_state,
+            "iterations": iterations,
+            "initial_amplitude": initial_amp,
+            "final_amplitude": results[-1]["amplitude"] if results else 0,
+            "results": results
+        }
+
+    def lottery_search(self, max_number: int, target: int, attempts: int = 1000) -> dict:
+        found = False
+        attempts_made = 0
+        probabilities = []
+        for i in range(attempts):
+            attempts_made += 1
+            phase = random.random() * 6.2832
+            self.tune(phase)
+            if target < 100:
+                s = self.get_state(target)
+                amp = (s[0]**2 + s[1]**2)**0.5
+                probabilities.append(amp)
+                if random.random() < amp * 0.5:
+                    found = True
+                    break
+        return {
+            "target": target,
+            "max_number": max_number,
+            "attempts_made": attempts_made,
+            "found": found,
+            "success_rate": (1.0 / max_number) * 100,
+            "max_probability": max(probabilities) if probabilities else 0
+        }