qbitwave 0.1.0__tar.gz

qbitwave-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juha Meskanen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qbitwave-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: qbitwave
+Version: 0.1.0
+Summary: Discrete emergent wavefunction
+Author-email: Juha Meskanen <juha@meskanen.com>
+Maintainer-email: Juha Meskanen <juha@meskanen.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/juhakm/qbitwave
+Project-URL: Bug Reports, https://github.com/juhakm/qbitwave
+Project-URL: Funding, https://meskanen.com
+Project-URL: Say Thanks!, http://meskanen.com
+Project-URL: Source, https://github.com/juhakm/qbitwave
+Keywords: physics,quantum
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Requires-Dist: types-pyz; extra == "dev"
+Dynamic: license-file
+
+# Bitwave
+
+**A minimal informational model of quantum emergence.**
+
+`Bitwave` is a Python library for simulating quantum-like wavefunctions as emergent properties of binary strings. It unifies bitstrings, amplitudes, and entropy into a single foundational object.
+
+## Key Concepts
+
+- **Bit = Geometry**: Each bit encodes structure.
+- **Bitstring = Universe State**: A single bitstring describes a possible quantum universe.
+- **Bitwave = Wavefunction**: A discrete quantum object derived purely from bits.
+
+## Features
+
+- Convert any bitstring into a complex amplitude vector
+- Extract |ψ|² and phase 
+- Measure entropy and emergent resolution
+
+
+## Example
+
+```python
+from bitwave import Bitwave
+
+bw = Bitwave("1101010111001001")
+amplitudes = bw.get_amplitudes()
+entropy = bw.entropy()

qbitwave-0.1.0/README.md

@@ -0,0 +1,27 @@
+# Bitwave
+
+**A minimal informational model of quantum emergence.**
+
+`Bitwave` is a Python library for simulating quantum-like wavefunctions as emergent properties of binary strings. It unifies bitstrings, amplitudes, and entropy into a single foundational object.
+
+## Key Concepts
+
+- **Bit = Geometry**: Each bit encodes structure.
+- **Bitstring = Universe State**: A single bitstring describes a possible quantum universe.
+- **Bitwave = Wavefunction**: A discrete quantum object derived purely from bits.
+
+## Features
+
+- Convert any bitstring into a complex amplitude vector
+- Extract |ψ|² and phase 
+- Measure entropy and emergent resolution
+
+
+## Example
+
+```python
+from bitwave import Bitwave
+
+bw = Bitwave("1101010111001001")
+amplitudes = bw.get_amplitudes()
+entropy = bw.entropy()

qbitwave-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["qbitwave"]
+
+[project]
+name = "qbitwave"
+version = "0.1.0"
+description = "Discrete emergent wavefunction"
+readme = {file = "README.md", content-type = "text/markdown"}
+requires-python = ">=3.9"
+license = "MIT"
+keywords = ["physics", "quantum"]
+authors = [
+  {name = "Juha Meskanen", email = "juha@meskanen.com" }
+]
+maintainers = [
+  {name = "Juha Meskanen", email = "juha@meskanen.com" }
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development",
+  "Programming Language :: Python :: 3.9",
+]
+
+dependencies = [
+  "numpy >=1.24",
+  "matplotlib >=3.7",
+  "scipy >=1.10"]
+
+
+[project.optional-dependencies]
+dev = [
+  "check-manifest",
+  "types-pyz"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/juhakm/qbitwave"
+"Bug Reports" = "https://github.com/juhakm/qbitwave"
+"Funding" = "https://meskanen.com"
+"Say Thanks!" = "http://meskanen.com"
+"Source" = "https://github.com/juhakm/qbitwave"
+
+
+[tool.mypy]
+files = ["bitwave/*.py", "examples/*.py"]
+ignore_missing_imports = false
+
+
+[tool.setuptools.package-data]
+"qbitwave" = ["py.typed"]
+

qbitwave-0.1.0/qbitwave/qbitwave.py

@@ -0,0 +1,120 @@
+import numpy as np
+
+class QBitwave:
+    def __init__(self, bitstring: str):
+        self.bitstring = bitstring
+        self.max_block_size = 32  # adjustable upper bound
+        self.min_block_size = 4   # minimum size to interpret anything
+        self.amplitudes = []
+        self.selected_block_size = None
+
+        self._analyze_bitstring()
+
+    def entropy(self):
+        """Return Shannon entropy of the probability distribution |ψ|²."""
+        probs = np.abs(self.amplitudes) ** 2
+        probs = np.clip(probs, 1e-10, 1.0)
+        return -np.sum(probs * np.log2(probs))
+
+    def num_states(self):
+        """Return the number of discrete quantum states (amplitudes)."""
+        return len(self.amplitudes)
+
+
+    def dimension(self):
+        """Dimension of the Hilbert space."""
+        return len(self.amplitudes)
+
+    def norm(self):
+        """Return the L2 norm of the wavefunction (should be ~1)."""
+        return np.linalg.norm(self.amplitudes)
+
+    def get_probability_distribution(self):
+        """Return the |ψ|² values as a NumPy array."""
+        return np.abs(self.amplitudes) ** 2
+
+    def get_phase_distribution(self):
+        """Return the phase angles in radians."""
+        return np.angle(self.amplitudes)
+
+    def __str__(self):
+        """Pretty-print the wavefunction in Dirac-style notation."""
+        lines = []
+        for i, amp in enumerate(self.amplitudes):
+            prob = abs(amp) ** 2
+            if prob < 1e-6:
+                continue  # skip negligible
+            lines.append(f"{amp:.3f} |{i:0{self._bitwidth()}b}⟩")
+        return " + ".join(lines) if lines else "∅"
+
+    def _bitwidth(self):
+        """Helper: number of bits needed to label states."""
+        n = len(self.amplitudes)
+        return max(1, int(np.ceil(np.log2(n))))
+
+
+    def _analyze_bitstring(self):
+        best_score = -np.inf
+        best_amplitudes = []
+        best_block_size = None
+
+        for block_size in range(self.min_block_size, self.max_block_size + 1, 2):
+            amps = self._interpret_as_wavefunction(block_size)
+            if not amps:
+                continue
+
+            score = self._score_amplitudes(amps)
+
+            if score > best_score:
+                best_score = score
+                best_amplitudes = amps
+                best_block_size = block_size
+
+        self.amplitudes = best_amplitudes
+        self.selected_block_size = best_block_size
+
+    def _interpret_as_wavefunction(self, block_size):
+        if len(self.bitstring) < block_size:
+            return []
+
+        step = block_size
+        half = step // 2
+        n_blocks = len(self.bitstring) // step
+        amplitudes = []
+
+        for i in range(n_blocks):
+            chunk = self.bitstring[i * step : (i + 1) * step]
+            real_bits = chunk[:half]
+            imag_bits = chunk[half:]
+
+            re = self._bits_to_signed_float(real_bits)
+            im = self._bits_to_signed_float(imag_bits)
+            amplitudes.append(complex(re, im))
+
+        norm = np.linalg.norm(amplitudes)
+        if norm == 0:
+            return []
+
+        return [amp / norm for amp in amplitudes]
+
+    def _bits_to_signed_float(self, bits: str):
+        if len(bits) == 0:
+            return 0.0
+        max_val = 2 ** (len(bits) - 1)
+        val = int(bits, 2)
+        if val >= max_val:
+            val -= 2 * max_val
+        return val / max_val  # in range [-1, 1)
+
+    def _score_amplitudes(self, amps):
+        # Use entropy of |ψ|² as a proxy for structure
+        probs = np.abs(amps) ** 2
+        probs = np.clip(probs, 1e-10, 1.0)
+        entropy = -np.sum(probs * np.log2(probs))
+        return entropy / len(amps)  # normalize per amplitude
+
+    def get_amplitudes(self):
+        return self.amplitudes
+
+    def get_selected_block_size(self):
+        return self.selected_block_size

qbitwave-0.1.0/qbitwave/qbitwave_visualizer.py

@@ -0,0 +1,45 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from wavefunction import QBitwave
+
+class QBitwaveVisualizer:
+    def __init__(self, wavefunction: QBitwave):
+        self.wf = wavefunction
+        self.amplitudes = self.wf.get_amplitudes()
+        self.indices = np.arange(len(self.amplitudes))
+        self.real = np.real(self.amplitudes)
+        self.imag = np.imag(self.amplitudes)
+        self.prob = np.abs(self.amplitudes) ** 2
+        self.phase = np.angle(self.amplitudes)
+
+    def plot_components(self, title: str = "QBitwave Components"):
+        fig, axs = plt.subplots(4, 1, figsize=(10, 10), sharex=True)
+
+        axs[0].bar(self.indices, self.real, color='blue')
+        axs[0].set_ylabel("Re(ψ)")
+        axs[0].set_title(title)
+
+        axs[1].bar(self.indices, self.imag, color='red')
+        axs[1].set_ylabel("Im(ψ)")
+
+        axs[2].bar(self.indices, self.prob, color='black')
+        axs[2].set_ylabel("|ψ|² (Prob)")
+
+        axs[3].bar(self.indices, self.phase, color='purple')
+        axs[3].set_ylabel("Arg(ψ)")
+        axs[3].set_xlabel("State Index")
+
+        plt.tight_layout()
+        plt.show()
+
+    def plot_heatmap(self, title: str = "QBitwave Heatmap"):
+        data = np.array([self.prob, self.phase])
+        fig, ax = plt.subplots(figsize=(10, 2))
+        im = ax.imshow(data, cmap='viridis', aspect='auto')
+
+        ax.set_yticks([0, 1])
+        ax.set_yticklabels(["|ψ|²", "Phase"])
+        ax.set_title(title)
+
+        plt.colorbar(im, ax=ax, orientation='vertical')
+        plt.show()

qbitwave-0.1.0/qbitwave.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: qbitwave
+Version: 0.1.0
+Summary: Discrete emergent wavefunction
+Author-email: Juha Meskanen <juha@meskanen.com>
+Maintainer-email: Juha Meskanen <juha@meskanen.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/juhakm/qbitwave
+Project-URL: Bug Reports, https://github.com/juhakm/qbitwave
+Project-URL: Funding, https://meskanen.com
+Project-URL: Say Thanks!, http://meskanen.com
+Project-URL: Source, https://github.com/juhakm/qbitwave
+Keywords: physics,quantum
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Requires-Dist: types-pyz; extra == "dev"
+Dynamic: license-file
+
+# Bitwave
+
+**A minimal informational model of quantum emergence.**
+
+`Bitwave` is a Python library for simulating quantum-like wavefunctions as emergent properties of binary strings. It unifies bitstrings, amplitudes, and entropy into a single foundational object.
+
+## Key Concepts
+
+- **Bit = Geometry**: Each bit encodes structure.
+- **Bitstring = Universe State**: A single bitstring describes a possible quantum universe.
+- **Bitwave = Wavefunction**: A discrete quantum object derived purely from bits.
+
+## Features
+
+- Convert any bitstring into a complex amplitude vector
+- Extract |ψ|² and phase 
+- Measure entropy and emergent resolution
+
+
+## Example
+
+```python
+from bitwave import Bitwave
+
+bw = Bitwave("1101010111001001")
+amplitudes = bw.get_amplitudes()
+entropy = bw.entropy()

qbitwave-0.1.0/qbitwave.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+qbitwave/__init__.py
+qbitwave/py.typed
+qbitwave/qbitwave.py
+qbitwave/qbitwave_visualizer.py
+qbitwave.egg-info/PKG-INFO
+qbitwave.egg-info/SOURCES.txt
+qbitwave.egg-info/dependency_links.txt
+qbitwave.egg-info/requires.txt
+qbitwave.egg-info/top_level.txt
+tests/test_qbitwave.py

qbitwave-0.1.0/qbitwave.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qbitwave-0.1.0/qbitwave.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy>=1.24
+matplotlib>=3.7
+scipy>=1.10
+
+[dev]
+check-manifest
+types-pyz

qbitwave-0.1.0/qbitwave.egg-info/top_level.txt

@@ -0,0 +1 @@
+qbitwave

qbitwave-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qbitwave-0.1.0/tests/test_qbitwave.py

@@ -0,0 +1,50 @@
+import unittest
+import numpy as np
+from qbitwave import QBitwave
+
+
+class TestQBitwave(unittest.TestCase):
+
+    def test_initialization(self):
+        bw = QBitwave("010101")
+        self.assertIsInstance(bw.bitstring, str)
+        self.assertTrue(all(b in "01" for b in bw.bitstring))
+
+    def test_amplitudes_length(self):
+        bw = QBitwave("1100110011")
+        amplitudes = bw.get_amplitudes()
+        self.assertIsInstance(amplitudes, np.ndarray)
+        self.assertGreaterEqual(len(amplitudes), 1)
+        self.assertTrue(np.iscomplexobj(amplitudes))
+
+    def test_amplitudes_normalization(self):
+        bw = QBitwave("1100110011")
+        amplitudes = bw.get_amplitudes()
+        prob_sum = np.sum(np.abs(amplitudes) ** 2)
+        self.assertAlmostEqual(prob_sum, 1.0, places=6)
+
+    def test_entropy_increases_with_structure(self):
+        bw_low = QBitwave("0000000000")
+        bw_high = QBitwave("1011001010")
+        entropy_low = bw_low.entropy()
+        entropy_high = bw_high.entropy()
+        self.assertLess(entropy_low, entropy_high)
+
+    def test_resolution_consistency(self):
+        bw = QBitwave("1011010110110101")
+        self.assertEqual(bw.resolution(), len(bw.get_amplitudes()))
+
+    def test_entropy_bounds(self):
+        bw = QBitwave("00000000")
+        entropy = bw.entropy()
+        self.assertGreaterEqual(entropy, 0)
+        self.assertLessEqual(entropy, np.log2(bw.resolution() + 1e-10))  # entropy ≤ log2(n)
+
+    def test_num_states(self):
+        bw = QBitwave("1010011101")
+        n = bw.num_states()
+        self.assertEqual(n, len(bw.get_amplitudes()))
+        self.assertGreater(n, 0)
+
+if __name__ == '__main__':
+    unittest.main()