softopt 0.5.2__tar.gz → 0.5.4__tar.gz

{softopt-0.5.2/softopt.egg-info → softopt-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softopt
-Version: 0.5.2
+Version: 0.5.4
 Summary: A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus
 Author: Ido Angel
 License: MIT
@@ -30,7 +30,7 @@ Each step is an update followed by an exact Newton correction computed from your
 
 ## Where it helps
 
-If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative and curvature of that model on every step, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
+If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative of that model on every step, plus the curvature along the same direction, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
 
 - **Quantum chemistry (VQE)** — H₂, H₄, BeH₂, HeH⁺, and larger multireference molecules
 - **Quantum control (GRAPE)** — the single cleanest result across every domain tested
@@ -114,7 +114,7 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 | Domain | Improvement | Win rate |
 |---|---|---|
-| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 93.9% | 17/20 |
+| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 91.6% | 16/20 |
 
 **Finance**
 

{softopt-0.5.2 → softopt-0.5.4}/README.md

@@ -6,7 +6,7 @@ Each step is an update followed by an exact Newton correction computed from your
 
 ## Where it helps
 
-If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative and curvature of that model on every step, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
+If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative of that model on every step, plus the curvature along the same direction, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
 
 - **Quantum chemistry (VQE)** — H₂, H₄, BeH₂, HeH⁺, and larger multireference molecules
 - **Quantum control (GRAPE)** — the single cleanest result across every domain tested
@@ -90,7 +90,7 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 | Domain | Improvement | Win rate |
 |---|---|---|
-| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 93.9% | 17/20 |
+| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 91.6% | 16/20 |
 
 **Finance**
 

{softopt-0.5.2 → softopt-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "softopt"
-version = "0.5.2"
+version = "0.5.4"
 description = "A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus"
 readme = "README.md"
 license = { text = "MIT" }

{softopt-0.5.2 → softopt-0.5.4}/softopt/__init__.py

@@ -23,4 +23,4 @@ __all__ = [
     "sadd", "sneg", "ssub", "smul", "sinv", "sdiv",
     "spow", "sroot", "ssqrt", "ssin", "scos", "sexp", "slog",
 ]
-__version__ = "0.5.2"
+__version__ = "0.5.4"

{softopt-0.5.2 → softopt-0.5.4}/softopt/compile.py

@@ -55,17 +55,30 @@ def soft_compile(model_fn, n_params=None, verify=True, verify_tol=1e-5):
     return g_delta
 
 
-def _verify(model_fn, g_delta, n_params, tol):
-    """Compare the exact compiled derivative against a finite difference of
-    the same model evaluated with plain floats."""
+def _verify(model_fn, g_delta, n_params, tol, n_points=6):
+    """Compare the exact compiled derivative against finite differences of the
+    same model, at several scattered points rather than one.
+
+    A single passing point proves very little: a model that branches can be
+    correct on one side and silently wrong on the other, and an operation that
+    discards the traced derivative (float(), np.array on the parameters) may
+    only sit inside one branch. Checking a spread of points catches that."""
     rng = np.random.default_rng(0)
-    for attempt in range(5):
-        theta = rng.normal(0.5, 1.0, n_params)
+    checked = 0
+    attempts = 0
+    while checked < n_points and attempts < n_points * 6:
+        attempts += 1
+        # spread the test points over several scales and both signs, so that
+        # branch conditions like `if x > 0` are exercised on both sides
+        spread = rng.choice([0.3, 1.0, 3.0])
+        theta = rng.normal(0.0, spread, n_params)
         direction = rng.normal(0, 1, n_params)
         try:
             exact = g_delta(theta, direction)
-        except ZeroDivisionError:
-            continue  # landed on a singular point; try another
+        except TypeError:
+            raise          # the model dropped the traced parameters -- a real fault
+        except (ZeroDivisionError, ValueError):
+            continue       # landed outside the model's domain; try elsewhere
         h = 1e-6
         try:
             f_plus = float(model_fn(list(theta + h * direction)))
@@ -79,23 +92,24 @@ def _verify(model_fn, g_delta, n_params, tol):
         approx = (f_plus - f_minus) / (2 * h)
 
         scale = max(abs(approx), abs(exact), 1.0)
-        if abs(exact - approx) / scale < tol:
-            return  # verified
         if abs(approx) < 1e-12 and abs(exact) < 1e-12:
-            continue  # flat direction here; uninformative, try another
+            continue  # flat here; uninformative, doesn't count as a check
+        checked += 1
+        if abs(exact - approx) / scale >= tol:
+            raise RuntimeError(
+                f"at theta={np.array2string(theta, precision=4)} the compiled "
+                f"derivative ({exact:.8g}) disagrees with a finite difference of "
+                f"your model ({approx:.8g}).\n\nIf your model branches, one branch "
+                "may use an operation that discards the traced derivative -- "
+                "float(), np.array() on the parameter list, or a call into a "
+                "library that only accepts plain numbers. Pass verify=False to "
+                "skip this check if you are confident the model is correct."
+            )
 
-        raise RuntimeError(
-            f"compiled derivative ({exact:.8g}) disagrees with a finite "
-            f"difference of your model ({approx:.8g}). Your model may use an "
-            "operation the soft algebra doesn't define, or may not be "
-            "differentiable at this point. Pass verify=False to skip this "
-            "check if you're confident it's correct."
+    if checked == 0:
+        import warnings
+        warnings.warn(
+            "soft_compile could not verify the model: every test point was "
+            "either singular or flat. The compiled function is returned unchecked.",
+            RuntimeWarning,
         )
-    # every attempt landed somewhere uninformative -- don't fail, but don't
-    # claim verification either
-    import warnings
-    warnings.warn(
-        "soft_compile could not verify the model: every test point was "
-        "either singular or flat. The compiled function is returned unchecked.",
-        RuntimeWarning,
-    )

{softopt-0.5.2 → softopt-0.5.4}/softopt/numpy_optimizer.py

@@ -1,14 +1,16 @@
 """
-SoftOpt: each step() call performs an update followed by an exact Newton
-correction computed from your own model.
+SoftOpt: each step() call performs an update followed by a Newton correction
+computed from your own model.
 
 Requirement: you supply g_delta(theta, delta) -> the exact directional
 derivative of your true objective along delta, computed from your own
 known model (circuit, projection, physical law). `soft_compile` generates
 this for you from a model written in ordinary Python.
 
-The correction is a bounded Newton step derived from the exact first and
-second directional derivatives of your model.
+The correction is a bounded Newton step. The first directional derivative is
+exact, propagated through your model by soft-number arithmetic. The second is
+a central finite difference OF that exact derivative -- an approximation, with
+the usual step-size trade-off, controlled by h_fd.
 """
 import numpy as np
 
@@ -29,6 +31,7 @@ class SoftOpt:
         self.v = None
         self.t = 0
         self.rng = np.random.default_rng(seed)
+        self._ablation_rng = None
         self._test_frozen_constant = _test_frozen_constant
 
     def step(self, theta, grad_estimate, _test_magnitude_source=None, _test_foreign_sampler=None, _test_rng=None):
@@ -69,6 +72,13 @@ class SoftOpt:
         n = theta.shape[0]
         gen_rng = _test_rng if _test_rng is not None else self.rng
         delta = gen_rng.choice([-1.0, 1.0], size=n)
+
+        # The ablation arms must not disturb the probe-direction stream, or
+        # a corrupted arm would also change every direction that follows and
+        # the comparison would no longer be like-for-like.
+        if self._ablation_rng is None:
+            self._ablation_rng = np.random.default_rng(
+                self.rng.integers(0, 2**63 - 1))
         D1 = self.g_delta(theta_after_adam, delta)
         gp = self.g_delta(theta_after_adam + self.h_fd * delta, delta)
         gm = self.g_delta(theta_after_adam - self.h_fd * delta, delta)
@@ -79,8 +89,9 @@ class SoftOpt:
         elif _test_magnitude_source == 'frozen':
             D2_used = self._test_frozen_constant
         elif _test_magnitude_source in ('foreign_point_and_dir', 'foreign_point_same_dir'):
-            theta_f = _test_foreign_sampler(gen_rng)
-            delta_f = gen_rng.choice([-1.0, 1.0], size=n) if _test_magnitude_source == 'foreign_point_and_dir' else delta
+            theta_f = _test_foreign_sampler(self._ablation_rng)
+            delta_f = (self._ablation_rng.choice([-1.0, 1.0], size=n)
+                       if _test_magnitude_source == 'foreign_point_and_dir' else delta)
             gp_f = self.g_delta(theta_f + self.h_fd * delta_f, delta_f)
             gm_f = self.g_delta(theta_f - self.h_fd * delta_f, delta_f)
             D2_used = abs((gp_f - gm_f) / (2 * self.h_fd))

{softopt-0.5.2 → softopt-0.5.4}/softopt/soft_number.py

@@ -87,8 +87,14 @@ def sroot(x, n):
     if b < 0 and n % 2 == 0:
         raise ValueError(f"even root (n={n}) of a soft number with b<0 "
                           "is not real-valued (Lemma 3.4)")
-    b_root = b ** (1.0 / n)
-    a_root = a / (n * b ** ((n - 1) / n))
+    if b < 0:
+        # Odd root of a negative real component: Python's ** returns a complex
+        # principal root here, so take the real root of |b| and restore the sign.
+        b_root = -((-b) ** (1.0 / n))
+    else:
+        b_root = b ** (1.0 / n)
+    # d/db b^(1/n) = b^(1/n) / (n*b), valid for either sign
+    a_root = a * b_root / (n * b)
     return (a_root, b_root)
 
 
@@ -198,15 +204,20 @@ class SoftNumber:
         return SoftNumber(self.a / (self.b * np.log(10.0)), np.log10(self.b))
 
     def __abs__(self):
-        """|x|: the real part determines the branch; the derivative follows
-        its sign (undefined exactly at 0, as for any absolute value)."""
+        """|x|. The real component picks the branch. At exactly zero the
+        derivative of |x| does not exist, so the zero-axis component is
+        reported as nan rather than silently taking one side."""
         if self.b < 0:
             return -self
+        if self.b == 0:
+            return SoftNumber(float("nan") if self.a != 0 else 0.0, 0.0)
         return SoftNumber(self.a, self.b)
 
-    # --- comparisons: ordered by the real component (book Definition 3.1,
-    # "Order": if a < b then a0 < b0). This lets models branch on parameter
-    # values normally; the compiled derivative is then valid on that branch.
+    # --- comparisons. These order by the REAL component only, which is what
+    # lets a model branch on a parameter value; the compiled derivative is then
+    # valid on whichever branch the parameters fall in. Note this is a practical
+    # ordering for tracing, not the book's Definition 3.1 ordering of the zero
+    # axis itself (a0 < b0 when a < b), which concerns the other component.
     def __lt__(self, other):
         return self.b < self._coerce(other).b
 

{softopt-0.5.2 → softopt-0.5.4/softopt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softopt
-Version: 0.5.2
+Version: 0.5.4
 Summary: A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus
 Author: Ido Angel
 License: MIT
@@ -30,7 +30,7 @@ Each step is an update followed by an exact Newton correction computed from your
 
 ## Where it helps
 
-If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative and curvature of that model on every step, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
+If your problem has a **known computation graph** — a quantum circuit, a physical simulator, a projection or measurement model, anything you can write down exactly, even if the *measurements* of it are noisy — SoftOpt computes an exact directional derivative of that model on every step, plus the curvature along the same direction, and uses them to correct the optimizer's trajectory. Validated, with real hardware-noise-model data, across:
 
 - **Quantum chemistry (VQE)** — H₂, H₄, BeH₂, HeH⁺, and larger multireference molecules
 - **Quantum control (GRAPE)** — the single cleanest result across every domain tested
@@ -114,7 +114,7 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 | Domain | Improvement | Win rate |
 |---|---|---|
-| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 93.9% | 17/20 |
+| Camera calibration (bundle adjustment, realistic pixel + outlier noise) | 91.6% | 16/20 |
 
 **Finance**
 

{softopt-0.5.2 → softopt-0.5.4}/tests/test_compile.py

@@ -145,3 +145,16 @@ def test_model_that_casts_to_float_is_caught():
         return float(v @ v)
     with pytest.raises(TypeError, match="doesn't depend on the traced parameters"):
         soft_compile(model, n_params=2)
+
+
+def test_a_branch_that_drops_the_derivative_is_caught():
+    """One passing point is not enough: a model can be correct on one branch
+    and silently wrong on the other."""
+    def branching(p):
+        x, y = p
+        if x > 0:
+            return x * x + 2.0 * y
+        return x * x + float(y) * 2.0     # float() discards y's derivative
+
+    with pytest.raises(RuntimeError, match="disagrees with a finite difference"):
+        soft_compile(branching, n_params=2)

{softopt-0.5.2 → softopt-0.5.4}/tests/test_soft_number.py

@@ -121,3 +121,22 @@ def test_class_matches_tuple_based_internals_exactly(xyz):
     assert np.allclose((x + y).as_tuple(), sadd(xt, yt))
     assert np.allclose((x * y).as_tuple(), smul(xt, yt))
     assert np.allclose(x.inverse().as_tuple(), sinv(xt))
+
+
+def test_odd_root_of_a_negative_real_component_is_real():
+    """Python's ** returns the complex principal root for (-8)**(1/3);
+    the real root is the one this algebra means."""
+    from softopt import sroot, spow
+    r = sroot((1.0, -8.0), 3)
+    assert not isinstance(r[0], complex) and not isinstance(r[1], complex)
+    assert np.isclose(r[1], -2.0)
+    assert np.isclose(r[0], 1.0 / 12.0)
+    back = spow(r, 3)
+    assert np.isclose(back[0], 1.0) and np.isclose(back[1], -8.0)
+
+
+def test_abs_reports_an_undefined_derivative_at_the_kink():
+    """|x| has no derivative at zero; report that rather than picking a side."""
+    assert np.isnan(abs(SoftNumber(1.0, 0.0)).a)
+    assert abs(SoftNumber(1.0, -2.0)) == SoftNumber(-1.0, 2.0)
+    assert abs(SoftNumber(1.0, 2.0)) == SoftNumber(1.0, 2.0)