galley-jl-python 0.1.0__tar.gz → 0.1.2__tar.gz

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: galley-jl-python
-Version: 0.1.0
+Version: 0.1.2
 Summary: Sparse Tensor Programming in Python powered by Finch.jl
 License-File: LICENSE
 Author: Willow Ahrens
@@ -79,8 +79,8 @@ Run any other command inside an environment with `pixi run`, for example
 The package is still built and published with Poetry (see
 [Publishing](#publishing)).
 
-### Working with a local copy of Finch.jl
-The `develop.py` script can be used to set up a local copy of Finch.jl for
+### Working with a local copy of Galley.jl
+The `develop.py` script can be used to set up a local copy of Galley.jl for
 development. Run it with `pixi run python develop.py`.
 
 ```
@@ -89,12 +89,12 @@ Usage:
 
 Options:
     --restore   Restore the original juliapkg.json file.
-    --path      Path to the local copy of Finch.jl [default: ../Finch.jl].
+    --path      Path to the local copy of Galley.jl [default: ../Galley.jl].
 ```
 
 ### Julia sysimage
 
-Most of Galley's startup time is Julia compiling Finch itself. A prebuilt Julia
+Most of Galley's startup time is Julia compiling Galley.jl itself. A prebuilt Julia
 sysimage removes it: the first matmul of a session drops from about 4.5 minutes
 to a few seconds.
 
@@ -112,7 +112,7 @@ to a few seconds.
 An image works only with the exact Julia and package versions it was built
 from. For this reason `src/galley_jl_python/juliapkg.json` pins Julia and every
 Julia package. Each image's name includes a hash of that environment. A local
-Finch.jl from `develop.py` therefore runs without the image.
+Galley.jl from `develop.py` therefore runs without the image.
 
 To update the Julia dependencies:
 

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/README.md

@@ -48,8 +48,8 @@ Run any other command inside an environment with `pixi run`, for example
 The package is still built and published with Poetry (see
 [Publishing](#publishing)).
 
-### Working with a local copy of Finch.jl
-The `develop.py` script can be used to set up a local copy of Finch.jl for
+### Working with a local copy of Galley.jl
+The `develop.py` script can be used to set up a local copy of Galley.jl for
 development. Run it with `pixi run python develop.py`.
 
 ```
@@ -58,12 +58,12 @@ Usage:
 
 Options:
     --restore   Restore the original juliapkg.json file.
-    --path      Path to the local copy of Finch.jl [default: ../Finch.jl].
+    --path      Path to the local copy of Galley.jl [default: ../Galley.jl].
 ```
 
 ### Julia sysimage
 
-Most of Galley's startup time is Julia compiling Finch itself. A prebuilt Julia
+Most of Galley's startup time is Julia compiling Galley.jl itself. A prebuilt Julia
 sysimage removes it: the first matmul of a session drops from about 4.5 minutes
 to a few seconds.
 
@@ -81,7 +81,7 @@ to a few seconds.
 An image works only with the exact Julia and package versions it was built
 from. For this reason `src/galley_jl_python/juliapkg.json` pins Julia and every
 Julia package. Each image's name includes a hash of that environment. A local
-Finch.jl from `develop.py` therefore runs without the image.
+Galley.jl from `develop.py` therefore runs without the image.
 
 To update the Julia dependencies:
 

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "galley-jl-python"
-version = "0.1.0"
+version = "0.1.2"
 description = "Sparse Tensor Programming in Python powered by Finch.jl"
 readme = "README.md"
 authors = [{name = "Willow Ahrens", email = "willow.marie.ahrens@gmail.com"}]

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/__init__.py

@@ -177,11 +177,14 @@ from .tensor import (
     log10,
     logaddexp,
     logical_and,
+    logical_not,
     logical_or,
     logical_xor,
     max,
+    maximum,
     mean,
     min,
+    minimum,
     moveaxis,
     nonzero,
     ones,
@@ -305,12 +308,15 @@ __all__ = [
     "log10",
     "logaddexp",
     "logical_and",
+    "logical_not",
     "logical_or",
     "logical_xor",
     "matmul",
     "max",
+    "maximum",
     "mean",
     "min",
+    "minimum",
     "moveaxis",
     "multiply",
     "nan",

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/compiled.py

@@ -73,7 +73,7 @@ def _recurse_iter_compute(x: IterObj, /, *, compute_kwargs: dict[str, Any]) -> I
     jl_len = len(jl_computed)
     # This doesn't return an iterable of arrays -- only a single array
     # for `len(jl_computed) == 1`
-    jl_computed = jl.Finch.compute(*jl_computed, **compute_kwargs)
+    jl_computed = jl.Galley.compute(*jl_computed, **compute_kwargs)
     if jl_len == 1:
         jl_computed = (jl_computed,)
 
@@ -129,16 +129,16 @@ class AbstractScheduler:
 
 class GalleyScheduler(AbstractScheduler):
     def get_julia_scheduler(self) -> JuliaObj:
-        return jl.Finch.galley_scheduler(verbose=self.verbose)
+        return jl.Galley.galley_scheduler(verbose=self.verbose)
 
 
 class DefaultScheduler(AbstractScheduler):
     def get_julia_scheduler(self) -> JuliaObj:
-        return jl.Finch.default_scheduler(verbose=self.verbose)
+        return jl.Galley.default_scheduler(verbose=self.verbose)
 
 
 def set_optimizer(opt: AbstractScheduler) -> None:
-    jl.Finch.set_scheduler_b(opt.get_julia_scheduler())
+    jl.Galley.set_scheduler_b(opt.get_julia_scheduler())
 
 
 set_optimizer(GalleyScheduler())
@@ -148,7 +148,7 @@ def lazy(tensor: Tensor) -> Tensor:
     from .tensor import Tensor
 
     if tensor.is_computed():
-        return Tensor(jl.Finch.LazyTensor(tensor._obj))
+        return Tensor(jl.Galley.LazyTensor(tensor._obj))
     return tensor
 
 
@@ -159,9 +159,9 @@ def compute(
 
     if not tensor.is_computed():
         if opt is None:
-            return Tensor(jl.Finch.compute(tensor._obj, tag=tag))
+            return Tensor(jl.Galley.compute(tensor._obj, tag=tag))
         return Tensor(
-            jl.Finch.compute(
+            jl.Galley.compute(
                 tensor._obj,
                 verbose=opt.verbose,
                 ctx=opt.get_julia_scheduler(),

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/julia.py

@@ -19,17 +19,16 @@ from . import _sysimage  # noqa: E402
 
 _sysimage.configure()
 
-# To change the version of Finch used, see the documentation for pyjuliapkg here: https://github.com/JuliaPy/pyjuliapkg
+# To change the version of Galley used, see the documentation for pyjuliapkg here: https://github.com/JuliaPy/pyjuliapkg
 # Use pyjuliapkg to modify the `juliapkg.json` file in the root of this repo.
-# You can also run `develop.py` to quickly use a local copy of Finch.jl.
+# You can also run `develop.py` to quickly use a local copy of Galley.jl.
 # An example development json is found in `juliapkg_dev.json`
 # Julia and all packages are pinned so the prebuilt sysimage matches; update the
-# pins with `scripts/sysimage/pin_julia_deps.py`. Finch is pinned to a git
-# commit (`rev`), which that script leaves alone.
+# pins with `scripts/sysimage/pin_julia_deps.py`.
 import juliacall as jc  # noqa: E402, F401
 from juliacall import Main as jl  # noqa: E402, F401
 
-jl.seval("using Finch")
+jl.seval("using Galley")
 jl.seval("using HDF5")
 jl.seval("using NPZ")
 jl.seval("using TensorMarket")

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/juliapkg.json

@@ -82,14 +82,17 @@
       "version": "=1.17.1"
     },
     "Finch": {
-      "rev": "368602490c2a106778afc9ca9d567a2201393012",
-      "url": "https://github.com/finch-tensor/Finch.jl",
-      "uuid": "9177782c-1635-4eb9-9bfb-d9dfa25e6bce"
+      "uuid": "9177782c-1635-4eb9-9bfb-d9dfa25e6bce",
+      "version": "=1.8.0"
     },
     "GPUArraysCore": {
       "uuid": "46192b85-c4d5-4398-a991-12ede77f4527",
       "version": "=0.2.1"
     },
+    "Galley": {
+      "uuid": "0b99cc74-af0a-4786-be99-594ac14242a4",
+      "version": "=0.2.2"
+    },
     "Gamma": {
       "uuid": "a0844989-3bd2-4988-8bea-c9407ab0941b",
       "version": "=1.2.0"

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/juliapkg_dev.json

@@ -1,10 +1,10 @@
 {
   "julia": "1.10 - 1.12",
   "packages": {
-    "Finch": {
+    "Galley": {
       "dev": true,
-      "path": "../Finch.jl",
-      "uuid": "9177782c-1635-4eb9-9bfb-d9dfa25e6bce"
+      "path": "../Galley.jl",
+      "uuid": "0b99cc74-af0a-4786-be99-594ac14242a4"
     },
     "HDF5": {
       "uuid": "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f",

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/linalg/_linalg.py

@@ -20,7 +20,7 @@ def vector_norm(
                 "is supported. Got: {axis}."
             )
 
-    result = Tensor(jl.Finch.norm(x._obj, ord))
+    result = Tensor(jl.Galley.norm(x._obj, ord))
     if keepdims:
         result = result[tuple(None for _ in range(x.ndim))]
     return result

{galley_jl_python-0.1.0 → galley_jl_python-0.1.2}/src/galley_jl_python/tensor.py

@@ -25,9 +25,9 @@ from .levels import (
 )
 from .typing import Device, DType, JuliaObj, OrderType, TupleOf3Arrays, spmatrix
 
-# Builds a 0-d Finch tensor in Julia so the element keeps its Julia eltype.
+# Builds a 0-d Galley tensor in Julia so the element keeps its Julia eltype.
 _scalar_to_0d = jl.seval(
-    "(T, fv, x) -> Finch.Tensor(Finch.Element{convert(T, fv)}(T[convert(T, x)]))"
+    "(T, fv, x) -> Galley.Tensor(Galley.Element{convert(T, fv)}(T[convert(T, x)]))"
 )
 
 
@@ -37,9 +37,65 @@ class SparseArray:
     """
 
 
+_WEAK_SCALAR_TYPE = """
+galley_weak_scalar_type(::Type{Bool}, ::Type{Bool}) = Bool
+galley_weak_scalar_type(::Type{T}, ::Type{Bool}) where {T} = T
+galley_weak_scalar_type(::Type{Bool}, ::Type{S}) where {S<:Integer} = S
+galley_weak_scalar_type(::Type{T}, ::Type{<:Integer}) where {T<:Number} = T
+galley_weak_scalar_type(
+    ::Type{T}, ::Type{<:AbstractFloat}
+) where {T<:Union{AbstractFloat,Complex}} = T
+galley_weak_scalar_type(::Type{T}, ::Type{<:Complex}) where {T<:Complex} = T
+galley_weak_scalar_type(
+    ::Type{T}, ::Type{<:Complex}
+) where {T<:AbstractFloat} = Complex{T}
+galley_weak_scalar_type(::Type, ::Type{S}) where {S} = S
+"""
+
+
+def _weak_scalar(element_type, value):
+    """A Python scalar operand as the Array API's weak scalars are: of the
+    array's type when it is of the same kind (an int with an integer array, a
+    float with a floating one), and otherwise of the default type (a float
+    with a Boolean array is a Float64). Reads lazy tensors' types too."""
+    if not hasattr(jl, "galley_weak_scalar_type"):
+        jl.seval(_WEAK_SCALAR_TYPE)
+    if isinstance(value, np.generic):
+        value = value.item()  # Julia reads np.bool_ as a Python object.
+    value_type = jl.typeof(jc.convert(jl.Any, value))
+    # jc.convert keeps the result in Julia; a Julia number returned to Python
+    # becomes a Python number, and so a Float64, again.
+    return jc.convert(jl.galley_weak_scalar_type(element_type, value_type), value)
+
+
+def _scalar_tensor(value) -> Tensor:
+    """A Julia scalar as a 0-d tensor whose fill is the scalar itself."""
+    return Tensor(jl.swizzle(_scalar_to_0d(jl.typeof(value), value, value)))
+
+
+# `where` picks with `ifelse` after promoting both branches to one type, as
+# the Array API requires. Julia's `ifelse` returns whichever branch it picks
+# unchanged, so on its own it would give a Union{Float64, Int64} result for a
+# float branch and an integer one.
+_where_op = jl.seval("(c, a, b) -> ifelse(c, promote(a, b)...)")
+
+
+def _element_fill(dtype, fill_value):
+    """fill_value as an Element level's fill for values of dtype.
+
+    Finch requires an isbits fill. Julia converts NumPy's numeric scalars to
+    Julia numbers, but not `np.bool_` or 0-d arrays (which `sparse.COO` uses for
+    its fill), so both are normalized first, and Booleans become Python bools.
+    """
+    fill_value = np.asarray(fill_value).item()
+    if np.dtype(dtype) == np.bool_:
+        return bool(fill_value)
+    return np.dtype(dtype).type(fill_value)
+
+
 class Tensor(_Display, SparseArray):
     """
-    A wrapper class for Finch.Tensor and Finch.SwizzleArray.
+    A wrapper class for Galley.Tensor and Galley.SwizzleArray.
 
     Constructors
     ------------
@@ -58,7 +114,7 @@ class Tensor(_Display, SparseArray):
 
     Parameters
     ----------
-    obj : np.ndarray or scipy.sparse or Storage or Finch.SwizzleArray
+    obj : np.ndarray or scipy.sparse or Storage or Galley.SwizzleArray
         Input to construct a Tensor. It's a no-copy operation of for NumPy and
         SciPy input. For Storage it's levels' description with order. The order
         numbers the dimensions from the fastest to slowest.  The leaf nodes have
@@ -75,7 +131,7 @@ class Tensor(_Display, SparseArray):
     Returns
     -------
     Tensor
-        Python wrapper for Finch Tensor.
+        Python wrapper for a Galley Tensor.
 
     Examples
     --------
@@ -108,10 +164,10 @@ class Tensor(_Display, SparseArray):
         fill_value: np.number | None = None,
         copy: bool | None = None,
     ):
-        if isinstance(obj, int | float | complex | bool | list):
+        if isinstance(obj, int | float | complex | bool | list | tuple):
             if copy is False:
                 raise ValueError(
-                    "copy=False isn't supported for scalar inputs and Python lists"
+                    "copy=False isn't supported for scalar inputs and Python sequences"
                 )
             obj = np.asarray(obj)
         if fill_value is None:
@@ -130,11 +186,11 @@ class Tensor(_Display, SparseArray):
                 obj.order, self.get_lvl_ndim(obj.levels_descr._obj)
             )
             self._obj = jl.swizzle(jl.Tensor(obj.levels_descr._obj), *order)
-        elif jl.isa(obj, jl.Finch.Tensor):  # raw-Julia-object constructors
+        elif jl.isa(obj, jl.Galley.Tensor):  # raw-Julia-object constructors
             if copy:
                 self._raise_julia_copy_not_supported()
             self._obj = jl.swizzle(obj, *tuple(range(1, jl.ndims(obj) + 1)))
-        elif jl.isa(obj, jl.Finch.SwizzleArray) or jl.isa(obj, jl.Finch.LazyTensor):
+        elif jl.isa(obj, jl.Galley.SwizzleArray) or jl.isa(obj, jl.Galley.LazyTensor):
             if copy:
                 self._raise_julia_copy_not_supported()
             self._obj = obj
@@ -165,14 +221,51 @@ class Tensor(_Display, SparseArray):
         return self._elemwise_op("/", other)
 
     def __floordiv__(self, other):
-        return self._elemwise_op("Finch.fld_nothrow", other)
+        return self._elemwise_op("Galley.fld_nothrow", other)
 
     def __mod__(self, other):
-        return self._elemwise_op("Finch.mod_nothrow", other)
+        return self._elemwise_op("Galley.mod_nothrow", other)
 
     def __pow__(self, other):
         return self._elemwise_op("^", other)
 
+    # Reflected operators, for a scalar on the left (`1 - x`, `2 ** x`).
+    def __radd__(self, other):
+        return self._elemwise_op("+", other, reflected=True)
+
+    def __rsub__(self, other):
+        return self._elemwise_op("-", other, reflected=True)
+
+    def __rmul__(self, other):
+        return self._elemwise_op("*", other, reflected=True)
+
+    def __rtruediv__(self, other):
+        return self._elemwise_op("/", other, reflected=True)
+
+    def __rfloordiv__(self, other):
+        return self._elemwise_op("Galley.fld_nothrow", other, reflected=True)
+
+    def __rmod__(self, other):
+        return self._elemwise_op("Galley.mod_nothrow", other, reflected=True)
+
+    def __rpow__(self, other):
+        return self._elemwise_op("^", other, reflected=True)
+
+    def __rand__(self, other):
+        return self._elemwise_op("&", other, reflected=True)
+
+    def __ror__(self, other):
+        return self._elemwise_op("|", other, reflected=True)
+
+    def __rxor__(self, other):
+        return self._elemwise_op("xor", other, reflected=True)
+
+    def __rlshift__(self, other):
+        return self._elemwise_op("<<", other, reflected=True)
+
+    def __rrshift__(self, other):
+        return self._elemwise_op(">>", other, reflected=True)
+
     @compiled()
     def __matmul__(self, other: Tensor) -> Tensor:
         if self.ndim == 0 or other.ndim == 0:
@@ -227,20 +320,21 @@ class Tensor(_Display, SparseArray):
     def __ne__(self, other):
         return self._elemwise_op("!=", other)
 
-    def _elemwise_op(self, op: str, other: Tensor | None = None) -> Tensor:
+    def _elemwise_op(
+        self, op: str, other: Tensor | None = None, *, reflected: bool = False
+    ) -> Tensor:
+        fn = jl.seval(op)
         if other is None:
-            result = jl.broadcast(jl.seval(op), self._obj)
+            result = jl.broadcast(fn, self._obj)
         else:
             if np.isscalar(other):
-                other = jc.convert(self.dtype, other)
+                other = _weak_scalar(jl.eltype(self._obj), other)
             else:
                 other = jl.permutedims(other._obj, tuple(range(other.ndim, 0, -1)))
             # inverse swizzle, so `broadcast` appends new dims to the front
-            result = jl.broadcast(
-                jl.seval(op),
-                jl.permutedims(self._obj, tuple(range(self.ndim, 0, -1))),
-                other,
-            )
+            this = jl.permutedims(self._obj, tuple(range(self.ndim, 0, -1)))
+            args = (other, this) if reflected else (this, other)
+            result = jl.broadcast(fn, *args)
             # swizzle back to the original order
             result = jl.permutedims(result, tuple(range(jl.ndims(result), 0, -1)))
 
@@ -280,9 +374,11 @@ class Tensor(_Display, SparseArray):
             key = _add_plus_one(key, self.shape)
 
         result = self._obj[key]
-        if jl.isa(result, jl.Finch.SwizzleArray) or jl.isa(result, jl.Finch.LazyTensor):
+        if jl.isa(result, jl.Galley.SwizzleArray) or jl.isa(
+            result, jl.Galley.LazyTensor
+        ):
             return Tensor(result)
-        if jl.isa(result, jl.Finch.Tensor):
+        if jl.isa(result, jl.Galley.Tensor):
             return Tensor(jl.swizzle(result, *range(1, jl.ndims(result) + 1)))
         # the Array API requires a 0-d array, not a scalar, for integer-only keys
         return Tensor(jl.swizzle(_scalar_to_0d(self.dtype, self.fill_value, result)))
@@ -311,7 +407,7 @@ class Tensor(_Display, SparseArray):
     def _is_dense(self) -> bool:
         lvl = self._obj.body.lvl
         for _ in self.shape:
-            if not jl.isa(lvl, jl.Finch.Dense):
+            if not jl.isa(lvl, jl.Galley.Dense):
                 return False
             lvl = lvl.lvl
         return True
@@ -320,6 +416,12 @@ class Tensor(_Display, SparseArray):
     def _order(self) -> tuple[int, ...]:
         return jl.typeof(self._obj).parameters[1]
 
+    @property
+    def T(self) -> Tensor:
+        if self.ndim != 2:
+            raise ValueError(f"`T` requires a 2-dimensional array, got {self.ndim=}.")
+        return self.permute_dims((1, 0))
+
     @property
     def mT(self) -> Tensor:
         axes = list(range(self.ndim))
@@ -340,7 +442,7 @@ class Tensor(_Display, SparseArray):
         return self
 
     def is_computed(self) -> bool:
-        return not jl.isa(self._obj, jl.Finch.LazyTensor)
+        return not jl.isa(self._obj, jl.Galley.LazyTensor)
 
     @classmethod
     def preprocess_order(cls, order: OrderType, ndim: int) -> tuple[int, ...]:
@@ -370,7 +472,7 @@ class Tensor(_Display, SparseArray):
         while True:
             ndim += 1
             lvl = lvl.lvl
-            if jl.isa(lvl, jl.Finch.Element):
+            if jl.isa(lvl, jl.Galley.Element):
                 break
         return ndim
 
@@ -433,12 +535,7 @@ class Tensor(_Display, SparseArray):
         order = cls.preprocess_order(order_char, arr.ndim)
         inv_order = tuple(i - 1 for i in jl.invperm(order))
 
-        dtype = arr.dtype.type
-        if (
-            dtype == np.bool_
-        ):  # Fails with: Finch currently only supports isbits defaults
-            dtype = jl_dtypes.bool
-        fill_value = dtype(fill_value)
+        fill_value = _element_fill(arr.dtype, fill_value)
         lvl = Element(fill_value, arr.reshape(-1, order=order_char))
         for i in inv_order:
             lvl = Dense(lvl, arr.shape[i])
@@ -503,11 +600,10 @@ class Tensor(_Display, SparseArray):
     def construct_coo_jl_object(
         cls, coords, data, shape, order, fill_value=0.0
     ) -> JuliaObj:
-        assert len(coords) == 2
         ndim = len(shape)
         order = cls.preprocess_order(order, ndim)
 
-        lvl = jl.Element(data.dtype.type(fill_value), data)
+        lvl = jl.Element(_element_fill(data.dtype, fill_value), data)
         ptr = jl.Vector[jl.Int]([1, len(data) + 1])
         tbl = tuple(jl.PlusOneVector(arr) for arr in coords)
 
@@ -532,11 +628,10 @@ class Tensor(_Display, SparseArray):
         assert len(shape) == 2
 
         data, indices, indptr = arg
-        dtype = data.dtype.type
         indices = jl.PlusOneVector(indices)
         indptr = jl.PlusOneVector(indptr)
 
-        lvl = jl.Element(dtype(fill_value), data)
+        lvl = jl.Element(_element_fill(data.dtype, fill_value), data)
         return jl.swizzle(
             jl.Tensor(
                 jl.Dense(jl.SparseList(lvl, shape[0], indptr, indices), shape[1])
@@ -579,7 +674,6 @@ class Tensor(_Display, SparseArray):
         assert isinstance(arg, tuple) and len(arg) == 3
 
         data, indices_list, indptr_list = arg
-        dtype = data.dtype.type
 
         assert len(indices_list) == len(shape) - 1
         assert len(indptr_list) == len(shape) - 1
@@ -587,7 +681,7 @@ class Tensor(_Display, SparseArray):
         indices_list = [jl.PlusOneVector(i) for i in indices_list]
         indptr_list = [jl.PlusOneVector(i) for i in indptr_list]
 
-        lvl = jl.Element(dtype(fill_value), data)
+        lvl = jl.Element(_element_fill(data.dtype, fill_value), data)
         for size, indices, indptr in zip(
             shape[:-1], indices_list, indptr_list, strict=False
         ):
@@ -906,7 +1000,20 @@ def astype(x: Tensor, dtype: DType, /, *, copy: bool = True) -> Tensor:
     return Tensor(jl.swizzle(result, *x.get_order(zero_indexing=False)))
 
 
-def where(condition: Tensor, x1: Tensor, x2: Tensor, /) -> Tensor:
+def where(
+    condition: Tensor,
+    x1: Tensor | complex,
+    x2: Tensor | complex,
+    /,
+) -> Tensor:
+    # A Python scalar takes the other branch's type when it is of the same
+    # kind, as the Array API's weak scalars do.
+    if np.isscalar(x1) and np.isscalar(x2):
+        raise TypeError("where needs at least one of x1 and x2 to be an array.")
+    if np.isscalar(x1):
+        x1 = _scalar_tensor(_weak_scalar(jl.eltype(x2._obj), x1))
+    if np.isscalar(x2):
+        x2 = _scalar_tensor(_weak_scalar(jl.eltype(x1._obj), x2))
     axis_cond, axis_x1, axis_x2 = (
         range(condition.ndim, 0, -1),
         range(x1.ndim, 0, -1),
@@ -914,7 +1021,7 @@ def where(condition: Tensor, x1: Tensor, x2: Tensor, /) -> Tensor:
     )
     # inverse swizzle, so `broadcast` appends new dims to the front
     result = jl.broadcast(
-        jl.ifelse,
+        _where_op,
         jl.permutedims(condition._obj, tuple(axis_cond)),
         jl.permutedims(x1._obj, tuple(axis_x1)),
         jl.permutedims(x2._obj, tuple(axis_x2)),
@@ -965,7 +1072,7 @@ def _reduce_sum_prod(
 
     result = Tensor(result)
 
-    if jl.isa(result._obj, jl.Finch.LazyTensor):
+    if jl.isa(result._obj, jl.Galley.LazyTensor):
         if dtype is not None:
             raise ValueError(
                 "`dtype` keyword for `sum` and `prod` in the lazy mode isn't supported"
@@ -1102,7 +1209,7 @@ def argmin(
     axis: int | None = None,
     keepdims: bool = False,
 ) -> Tensor:
-    return _reduce(x, jl.Finch.argmin_python, axis, keepdims)
+    return _reduce(x, jl.Galley.argmin_python, axis, keepdims)
 
 
 def argmax(
@@ -1112,7 +1219,7 @@ def argmax(
     axis: int | None = None,
     keepdims: bool = False,
 ) -> Tensor:
-    return _reduce(x, jl.Finch.argmax_python, axis, keepdims)
+    return _reduce(x, jl.Galley.argmax_python, axis, keepdims)
 
 
 def squeeze(
@@ -1162,7 +1269,7 @@ def eye(
     _validate_device(device)
     n_cols = n_rows if n_cols is None else n_cols
     dtype = jl_dtypes.float64 if dtype is None else dtype
-    tns = jl.Finch.eye_python(n_rows, n_cols, k, dtype(False))
+    tns = jl.Galley.eye_python(n_rows, n_cols, k, dtype(False))
     if format == "coo":
         return Tensor(tns)
     if format == "dense":
@@ -1316,16 +1423,48 @@ def logaddexp(x1: Tensor, x2: Tensor, /) -> Tensor:
     return log(exp(x1) + exp(x2))
 
 
+def _truth(x: Tensor) -> Tensor:
+    """x as Bools, the truth the logical operators read (Galley.and and its
+    relatives take only Bools)."""
+    # eltype, unlike `dtype`, also reads lazy tensors (einop's operands).
+    if isinstance(x, Tensor) and jl.eltype(x._obj) == jl.Bool:
+        return x
+    return x != 0
+
+
+def _logical(op: str, x1: Tensor, x2: Tensor) -> Tensor:
+    if not isinstance(x1, Tensor):
+        x1, x2 = x2, x1  # The logical operators commute.
+    return _truth(x1)._elemwise_op(op, _truth(x2))
+
+
 def logical_and(x1: Tensor, x2: Tensor, /) -> Tensor:
-    return x1._elemwise_op("Finch.and", x2)
+    return _logical("Galley.and", x1, x2)
 
 
 def logical_or(x1: Tensor, x2: Tensor, /) -> Tensor:
-    return x1._elemwise_op("Finch.or", x2)
+    return _logical("Galley.or", x1, x2)
 
 
 def logical_xor(x1: Tensor, x2: Tensor, /) -> Tensor:
-    return x1._elemwise_op("Finch.xor", x2)
+    return _logical("Galley.xor", x1, x2)
+
+
+def maximum(x1: Tensor, x2: Tensor, /) -> Tensor:
+    if not isinstance(x1, Tensor):
+        x1, x2 = x2, x1  # max commutes.
+    return x1._elemwise_op("max", x2)
+
+
+def minimum(x1: Tensor, x2: Tensor, /) -> Tensor:
+    if not isinstance(x1, Tensor):
+        x1, x2 = x2, x1  # min commutes.
+    return x1._elemwise_op("min", x2)
+
+
+def logical_not(x: Tensor, /) -> Tensor:
+    # einop's `not` and `logical_not` resolve to this function.
+    return x._elemwise_op("iszero")
 
 
 def power(x1: Tensor, x2: Tensor, /) -> Tensor: