mplang-nightly 0.1.dev158__py3-none-any.whl → 0.1.dev268__py3-none-any.whl

mplang/{ops/builtin.py → v1/ops/basic.py}

@@ -15,18 +15,25 @@
 
 from jax.tree_util import PyTreeDef, tree_flatten
 
-from mplang.core.dtype import UINT8, UINT64
-from mplang.core.mpobject import MPObject  # Needed for constant() triad return typing
-from mplang.core.pfunc import PFunction
-from mplang.core.table import TableLike, TableType
-from mplang.core.tensor import ScalarType, Shape, TensorLike, TensorType
-from mplang.ops.base import stateless_mod
-from mplang.utils import table_utils
-
-_BUILTIN_MOD = stateless_mod("builtin")
-
-
-@_BUILTIN_MOD.simple_op()
+from mplang.v1.core import (
+    UINT8,
+    UINT64,
+    MPObject,
+    PFunction,
+    ScalarType,
+    Shape,
+    TableLike,
+    TableType,
+    TensorLike,
+    TensorType,
+)
+from mplang.v1.ops.base import stateless_mod
+from mplang.v1.utils import table_utils
+
+_BASIC_MOD = stateless_mod("basic")
+
+
+@_BASIC_MOD.simple_op()
 def identity(x: TensorType) -> TensorType:
     """Return the input type unchanged.
 
@@ -40,7 +47,7 @@ def identity(x: TensorType) -> TensorType:
     return x
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def read(*, path: str, ty: TensorType) -> TensorType:
     """Declare reading a value of type ``ty`` from ``path`` (type-only).
 
@@ -63,7 +70,7 @@ def read(*, path: str, ty: TensorType) -> TensorType:
     return ty
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def write(x: TensorType, *, path: str) -> TensorType:
     """Declare writing the input value to ``path`` and return the same type.
 
@@ -77,7 +84,7 @@ def write(x: TensorType, *, path: str) -> TensorType:
     return x
 
 
-@_BUILTIN_MOD.op_def()
+@_BASIC_MOD.op_def()
 def constant(
     data: TensorLike | ScalarType | TableLike,
 ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
@@ -89,7 +96,7 @@ def constant(
 
     Returns:
         Tuple[PFunction, list[MPObject], PyTreeDef]:
-        - PFunction: ``fn_type='builtin.constant'`` with one output whose type
+        - PFunction: ``fn_type='basic.constant'`` with one output whose type
             matches ``data``; payload serialized via ``data_bytes`` with
             ``data_format`` ('bytes[numpy]' or 'bytes[csv]').
         - list[MPObject]: Empty (no inputs captured).
@@ -101,8 +108,9 @@ def constant(
     out_type: TableType | TensorType
 
     if isinstance(data, TableLike):
-        data_bytes = table_utils.dataframe_to_csv(data)
-        data_format = "bytes[csv]"
+        format = "parquet"
+        data_bytes = table_utils.encode_table(data, format=format)
+        data_format = f"bytes[{format}]"
         out_type = TableType.from_tablelike(data)
     elif isinstance(data, ScalarType):
         out_type = TensorType.from_obj(data)
@@ -120,7 +128,7 @@ def constant(
         data_format = "bytes[numpy]"
 
     pfunc = PFunction(
-        fn_type="builtin.constant",
+        fn_type="basic.constant",
         ins_info=(),
         outs_info=(out_type,),
         data_bytes=data_bytes,
@@ -130,7 +138,7 @@ def constant(
     return pfunc, [], treedef
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def rank() -> TensorType:
     """Return the scalar UINT64 tensor type for the current party rank.
 
@@ -140,7 +148,7 @@ def rank() -> TensorType:
     return TensorType(UINT64, ())
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def prand(*, shape: Shape = ()) -> TensorType:
     """Declare a private random UINT64 tensor with the given shape.
 
@@ -153,7 +161,7 @@ def prand(*, shape: Shape = ()) -> TensorType:
     return TensorType(UINT64, shape)
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def debug_print(
     x: TensorType | TableType, *, prefix: str = ""
 ) -> TableType | TensorType:
@@ -169,7 +177,7 @@ def debug_print(
     return x
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def pack(x: TensorType | TableType) -> TensorType:
     """Serialize a tensor/table into a byte vector (type-only).
 
@@ -189,7 +197,7 @@ def pack(x: TensorType | TableType) -> TensorType:
     return TensorType(UINT8, (-1,))
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | TableType:
     """Deserialize a byte vector into the explicit output type.
 
@@ -215,7 +223,7 @@ def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | Tab
     return out_ty
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
     """Convert a homogeneous-typed table to a dense 2D tensor.
 
@@ -248,7 +256,7 @@ def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
     return TensorType(first, shape)  # type: ignore[arg-type]
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def tensor_to_table(tensor: TensorType, *, column_names: list[str]) -> TableType:
     """Convert a rank-2 tensor into a table with named columns.
 

mplang/v1/ops/crypto.py

@@ -0,0 +1,262 @@
+# Copyright 2025 Ant Group Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Crypto frontend operations: operation signatures, types, and high-level semantics.
+
+Scope and contracts:
+- This module defines portable API shapes; it does not implement cryptography.
+- Backends execute the operations and must meet the security semantics required
+    by the deployment (confidentiality, authenticity, correctness, etc.).
+- The enc/dec API in this frontend uses a conventional 12-byte nonce prefix
+    (ciphertext = nonce || payload), and dec expects that format. Other security
+    properties (e.g., AEAD) are backend responsibilities.
+"""
+
+from __future__ import annotations
+
+from jax.tree_util import PyTreeDef, tree_flatten
+
+from mplang.v1.core import UINT8, TensorType
+from mplang.v1.core.mpobject import MPObject
+from mplang.v1.core.pfunc import PFunction
+from mplang.v1.ops.base import stateless_mod
+
+_CRYPTO_MOD = stateless_mod("crypto")
+
+
+def _get_algo_overhead(algo: str) -> int:
+    """Get ciphertext overhead for a given encryption algorithm.
+
+    Args:
+        algo: Encryption algorithm identifier
+
+    Returns:
+        int: Number of overhead bytes added to plaintext length
+    """
+    overhead_map = {
+        "aes-ctr": 16,  # nonce only (legacy compatibility)
+        "aes-gcm": 28,  # nonce(12) + tag(16) for AES-GCM
+        "sm4-gcm": 28,  # nonce(12) + tag(16) for SM4-GCM
+    }
+
+    if algo not in overhead_map:
+        # return unknown overhead as -1
+        return -1
+    return overhead_map[algo]
+
+
+@_CRYPTO_MOD.simple_op()
+def keygen(*, length: int = 32) -> TensorType:
+    """Generate random bytes for symmetric keys or generic randomness.
+
+    API: keygen(length: int = 32) -> key: u8[length]
+
+    Notes:
+    - Frontend defines the type/shape; backend provides randomness.
+    - Raises ValueError when length <= 0.
+    """
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    return TensorType(UINT8, (length,))
+
+
+@_CRYPTO_MOD.op_def()
+def enc(
+    plaintext: MPObject, key: MPObject, algo: str = "aes-ctr"
+) -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """Symmetric encryption with algorithm-aware output sizing.
+
+    API: enc(plaintext: u8[N], key: u8[M], *, algo: str = "aes-ctr") -> ciphertext: u8[N + overhead]
+
+    Supported algorithms and overhead:
+    - "aes-ctr": 16 bytes (nonce only, legacy compatibility)
+    - "aes-gcm": 28 bytes (nonce + 16-byte authentication tag)
+    - "sm4-gcm": 28 bytes (nonce + 16-byte authentication tag)
+
+    The algo parameter is stored in the PFunction attributes for backend use.
+    """
+    pt_ty = plaintext
+    if pt_ty.dtype != UINT8:
+        raise TypeError("enc expects UINT8 plaintext")
+    if len(pt_ty.shape) != 1:
+        raise TypeError("enc expects 1-D plaintext")
+
+    # Validate and get overhead for the specified algorithm
+    overhead = _get_algo_overhead(algo)
+    length = pt_ty.shape[0]
+    if length >= 0 and overhead >= 0:
+        outs_info = (TensorType(UINT8, (length + overhead,)),)
+    else:
+        # Unknown length or overhead, return dynamic length
+        outs_info = (TensorType(UINT8, (-1,)),)
+
+    ins_info = (TensorType.from_obj(pt_ty), TensorType.from_obj(key))
+    pfunc = PFunction(
+        fn_type="crypto.enc",
+        ins_info=ins_info,
+        outs_info=outs_info,
+        algo=algo,
+    )
+    _, treedef = tree_flatten(outs_info[0])
+    return pfunc, [plaintext, key], treedef
+
+
+@_CRYPTO_MOD.op_def()
+def dec(
+    ciphertext: MPObject, key: MPObject, algo: str = "aes-ctr"
+) -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """Symmetric decryption with algorithm-aware input sizing.
+
+    API: dec(ciphertext: u8[N + overhead], key: u8[M], *, algo: str = "aes-ctr") -> plaintext: u8[N]
+
+    Supported algorithms and overhead:
+    - "aes-ctr": 16 bytes (nonce only, legacy compatibility)
+    - "aes-gcm": 28 bytes (nonce + 16-byte authentication tag)
+    - "sm4-gcm": 28 bytes (nonce + 16-byte authentication tag)
+
+    The algo parameter is stored in the PFunction attributes for backend use.
+    Backend is responsible for parsing the ciphertext format according to algo.
+    """
+    ct_ty = ciphertext
+    if ct_ty.dtype != UINT8:
+        raise TypeError("dec expects UINT8 ciphertext")
+    if len(ct_ty.shape) != 1:
+        raise TypeError("dec expects 1-D ciphertext")
+
+    # Validate and get overhead for the specified algorithm
+    overhead = _get_algo_overhead(algo)
+    length = ct_ty.shape[0]
+
+    # Validate minimum ciphertext length
+    if length >= 0 and overhead >= 0 and length < overhead:
+        raise TypeError(
+            f"dec expects ciphertext with at least {overhead} bytes for algo='{algo}', but got {length} bytes"
+        )
+
+    # Compute output plaintext length
+    if length >= 0 and overhead >= 0:
+        outs_info = (TensorType(UINT8, (length - overhead,)),)
+    else:
+        # Unknown length or overhead, return dynamic length
+        outs_info = (TensorType(UINT8, (-1,)),)
+
+    ins_info = (TensorType.from_obj(ct_ty), TensorType.from_obj(key))
+    pfunc = PFunction(
+        fn_type="crypto.dec",
+        ins_info=ins_info,
+        outs_info=outs_info,
+        algo=algo,
+    )
+    _, treedef = tree_flatten(outs_info[0])
+    return pfunc, [ciphertext, key], treedef
+
+
+@_CRYPTO_MOD.op_def()
+def kem_keygen(suite: str = "x25519") -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """KEM-style keypair generation: returns (sk, pk) bytes.
+
+    API: kem_keygen(suite: str = "x25519") -> (sk: u8[32], pk: u8[32])
+
+    The suite parameter is stored in the PFunction attributes for backend use.
+    """
+    if suite == "x25519":
+        sk_ty = TensorType(UINT8, (32,))
+        pk_ty = TensorType(UINT8, (32,))
+    else:
+        # Unknown suite, return dynamic lengths
+        sk_ty = TensorType(UINT8, (-1,))
+        pk_ty = TensorType(UINT8, (-1,))
+    outs_info = (sk_ty, pk_ty)
+
+    pfunc = PFunction(
+        fn_type="crypto.kem_keygen",
+        ins_info=(),
+        outs_info=outs_info,
+        suite=suite,
+    )
+    _, treedef = tree_flatten(outs_info)
+    return pfunc, [], treedef
+
+
+@_CRYPTO_MOD.op_def()
+def kem_derive(
+    sk: MPObject, peer_pk: MPObject, suite: str = "x25519"
+) -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """KEM-style shared secret derivation: returns secret bytes.
+
+    API: kem_derive(sk: u8[32], peer_pk: u8[32], suite: str = "x25519") -> secret: u8[32]
+
+    The suite parameter is stored in the PFunction attributes for backend use.
+    """
+    # Validate input types
+    if sk.dtype != UINT8:
+        raise TypeError("kem_derive expects UINT8 secret key")
+    if peer_pk.dtype != UINT8:
+        raise TypeError("kem_derive expects UINT8 peer public key")
+    if len(sk.shape) != 1 or len(peer_pk.shape) != 1:
+        raise TypeError("kem_derive expects 1-D inputs")
+
+    if suite == "x25519":
+        if sk.shape[0] != 32 or peer_pk.shape[0] != 32:
+            raise TypeError("kem_derive expects 32-byte keys for suite 'x25519'")
+        secret_ty = TensorType(UINT8, (32,))
+    else:
+        # Unknown suite, return dynamic length
+        secret_ty = TensorType(UINT8, (-1,))
+    outs_info = (secret_ty,)
+
+    ins_info = (TensorType.from_obj(sk), TensorType.from_obj(peer_pk))
+    pfunc = PFunction(
+        fn_type="crypto.kem_derive",
+        ins_info=ins_info,
+        outs_info=outs_info,
+        suite=suite,
+    )
+    _, treedef = tree_flatten(outs_info[0])
+    return pfunc, [sk, peer_pk], treedef
+
+
+@_CRYPTO_MOD.op_def()
+def hkdf(
+    secret: MPObject, info: str, hash: str = "SHA-256"
+) -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """HKDF-style key derivation: returns a 32-byte key.
+
+    API: hkdf(secret: u8[N], info: str, hash: str = "SHA-256") -> key: u8[32]
+
+    The hash parameter is stored in the PFunction attributes for backend use.
+    """
+    # Validate input types
+    if secret.dtype != UINT8:
+        raise TypeError("hkdf expects UINT8 secret")
+    if len(secret.shape) != 1:
+        raise TypeError("hkdf expects 1-D secret")
+
+    if hash == "SHA-256" or hash == "SM3":
+        outs_info = (TensorType(UINT8, (32,)),)
+    else:
+        # Unknown hash, return dynamic length
+        outs_info = (TensorType(UINT8, (-1,)),)
+
+    ins_info = (TensorType.from_obj(secret),)
+    pfunc = PFunction(
+        fn_type="crypto.hkdf",
+        ins_info=ins_info,
+        outs_info=outs_info,
+        hash=hash,
+        info=info,
+    )
+    _, treedef = tree_flatten(outs_info[0])
+    return pfunc, [secret], treedef

mplang/v1/ops/fhe.py

@@ -0,0 +1,272 @@
+# Copyright 2025 Ant Group Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mplang.v1.core import UINT8, TensorType
+from mplang.v1.ops.base import stateless_mod
+
+_fhe_MOD = stateless_mod("fhe")
+
+
+@_fhe_MOD.simple_op()
+def keygen(
+    *,
+    scheme: str = "CKKS",
+    poly_modulus_degree: int = 8192,
+    coeff_mod_bit_sizes: tuple[int, ...] | None = None,
+    global_scale: int | None = None,
+    plain_modulus: int | None = None,
+) -> tuple[TensorType, TensorType, TensorType]:
+    """Generate an FHE key pair for Vector backend: returns (private_context, public_context, evaluation_context).
+
+    Args:
+        scheme: FHE scheme to use ("CKKS" for approximate, "BFV" for exact integer)
+        poly_modulus_degree: Polynomial modulus degree (default: 8192)
+        coeff_mod_bit_sizes: Coefficient modulus bit sizes for CKKS (optional)
+        global_scale: Global scale for CKKS (optional)
+        plain_modulus: Plain modulus for BFV (optional)
+
+    Returns:
+        Tuple of (private_context, public_context, evaluation_context) represented as UINT8[(-1, 0)]
+
+    Contexts are represented with a sentinel TensorType UINT8[(-1, 0)] to indicate
+    non-structural, backend-only handles.
+
+    Note: Vector backend only supports 1D data. For multi-dimensional tensors,
+    use mplang.ops.fhe instead.
+    """
+    if scheme not in ("CKKS", "BFV"):
+        raise ValueError("Unsupported scheme. Choose either 'CKKS' or 'BFV'.")
+    if scheme == "CKKS":
+        assert plain_modulus is None, "plain_modulus is not used in CKKS scheme."
+    context_spec = TensorType(UINT8, (-1, 0))
+    return context_spec, context_spec, context_spec
+
+
+@_fhe_MOD.simple_op()
+def encrypt(plaintext: TensorType, context: TensorType) -> TensorType:
+    """Encrypt plaintext using FHE Vector backend: returns ciphertext with same semantic type.
+
+    Args:
+        plaintext: Data to encrypt (scalar or 1D vector only)
+        context: FHE context (private or public)
+
+    Returns:
+        Ciphertext with same semantic type as plaintext
+
+    Raises:
+        ValueError: If plaintext has more than 1 dimension
+
+    Note: Vector backend only supports scalars (shape=()) and 1D vectors (shape=(n,)).
+    For multi-dimensional data, use mplang.ops.fhe.encrypt instead.
+    """
+    _ = context
+    if len(plaintext.shape) > 1:
+        raise ValueError(
+            f"FHE Vector backend only supports 1D data. Got shape {plaintext.shape}. "
+            "Use mplang.ops.fhe for multi-dimensional tensors."
+        )
+    return plaintext
+
+
+@_fhe_MOD.simple_op()
+def decrypt(ciphertext: TensorType, context: TensorType) -> TensorType:
+    """Decrypt ciphertext using FHE Vector backend: returns plaintext with same semantic type.
+
+    Args:
+        ciphertext: Encrypted data to decrypt (scalar or 1D vector)
+        context: FHE context (must be private context with secret key)
+
+    Returns:
+        Plaintext with same semantic type as ciphertext
+
+    Note: Ciphertext encrypted with public context can be decrypted with
+    the corresponding private context.
+    """
+    _ = context
+    return ciphertext
+
+
+@_fhe_MOD.simple_op()
+def add(operand1: TensorType, operand2: TensorType) -> TensorType:
+    """Add two FHE operands (ciphertext + ciphertext or ciphertext + plaintext).
+
+    Args:
+        operand1: First operand (ciphertext or plaintext, scalar or 1D vector)
+        operand2: Second operand (ciphertext or plaintext, scalar or 1D vector)
+
+    Returns:
+        Result of homomorphic addition
+
+    Raises:
+        ValueError: If operands have incompatible shapes or dtypes
+
+    Note: At least one operand must be ciphertext. Both operands must have
+    the same shape (no broadcasting in Vector backend).
+    """
+    assert operand1.dtype == operand2.dtype, (
+        f"Operand dtypes must match, got {operand1.dtype} and {operand2.dtype}."
+    )
+    assert operand1.shape == operand2.shape, (
+        f"Operand shapes must match, got {operand1.shape} and {operand2.shape}."
+    )
+    return operand1
+
+
+@_fhe_MOD.simple_op()
+def sub(operand1: TensorType, operand2: TensorType) -> TensorType:
+    """Subtract two FHE operands (ciphertext - ciphertext or ciphertext - plaintext).
+
+    Args:
+        operand1: First operand (ciphertext or plaintext, scalar or 1D vector)
+        operand2: Second operand (ciphertext or plaintext, scalar or 1D vector)
+
+    Returns:
+        Result of homomorphic subtraction
+
+    Raises:
+        ValueError: If operands have incompatible shapes or dtypes
+
+    Note: At least one operand must be ciphertext. Both operands must have
+    the same shape (no broadcasting in Vector backend).
+    """
+    assert operand1.dtype == operand2.dtype, (
+        f"Operand dtypes must match, got {operand1.dtype} and {operand2.dtype}."
+    )
+    assert operand1.shape == operand2.shape, (
+        f"Operand shapes must match, got {operand1.shape} and {operand2.shape}."
+    )
+    return operand1
+
+
+@_fhe_MOD.simple_op()
+def mul(operand1: TensorType, operand2: TensorType) -> TensorType:
+    """Multiply two FHE operands (ciphertext * ciphertext or ciphertext * plaintext).
+
+    Args:
+        operand1: First operand (ciphertext or plaintext, scalar or 1D vector)
+        operand2: Second operand (ciphertext or plaintext, scalar or 1D vector)
+
+    Returns:
+        Result of homomorphic multiplication
+
+    Raises:
+        ValueError: If operands have incompatible shapes or dtypes
+
+    Note: At least one operand must be ciphertext. Both operands must have
+    the same shape (no broadcasting in Vector backend).
+    For BFV scheme, plaintext operands must be integers.
+    """
+    assert operand1.dtype == operand2.dtype, (
+        f"Operand dtypes must match, got {operand1.dtype} and {operand2.dtype}."
+    )
+    assert operand1.shape == operand2.shape, (
+        f"Operand shapes must match, got {operand1.shape} and {operand2.shape}."
+    )
+    return operand1
+
+
+@_fhe_MOD.simple_op()
+def dot(operand1: TensorType, operand2: TensorType) -> TensorType:
+    """Compute dot product of FHE operands (ciphertext · ciphertext or ciphertext · plaintext).
+
+    Args:
+        operand1: First operand (ciphertext or plaintext, must be 1D vector)
+        operand2: Second operand (ciphertext or plaintext, must be 1D vector)
+
+    Returns:
+        Scalar result of homomorphic dot product (shape=())
+
+    Raises:
+        ValueError: If operands are not 1D vectors or have different lengths
+
+    Note: Both operands must be 1D vectors (not scalars). For scalar multiplication,
+    use mul() instead. This operation always returns a scalar.
+    """
+    if len(operand1.shape) != 1:
+        raise ValueError(
+            f"Dot product requires 1D vectors, got shape {operand1.shape} for operand1"
+        )
+    if len(operand2.shape) != 1:
+        raise ValueError(
+            f"Dot product requires 1D vectors, got shape {operand2.shape} for operand2"
+        )
+    if operand1.shape[0] != operand2.shape[0]:
+        raise ValueError(
+            f"Dot product dimension mismatch: {operand1.shape[0]} vs {operand2.shape[0]}"
+        )
+
+    # Dot product of 1D vectors returns a scalar
+    return TensorType(operand1.dtype, ())
+
+
+@_fhe_MOD.simple_op()
+def polyval(ciphertext: TensorType, coeffs: TensorType) -> TensorType:
+    """Evaluate polynomial on encrypted data with plaintext coefficients.
+
+    Args:
+        ciphertext: Encrypted data (scalar or 1D vector)
+        coeffs: Plaintext polynomial coefficients as 1D array [c0, c1, c2, ...]
+                representing c0 + c1*x + c2*x^2 + ...
+
+    Returns:
+        Result of polynomial evaluation with same shape and dtype as ciphertext
+
+    Raises:
+        ValueError: If coefficients array is not 1D or has fewer than 2 elements
+
+    Note: Polynomial must have degree >= 1 (at least 2 coefficients required).
+    Constant polynomials (degree 0, single coefficient) are NOT supported due to
+    TenSEAL limitation. For constant values, use: ct * 0 + constant instead.
+    For BFV scheme, coefficients must be integers.
+
+    Common use case - Sigmoid approximation:
+        sigmoid_coeffs = [0.5, 0.15012, 0.0, -0.0018027]
+        result = polyval(ciphertext, sigmoid_coeffs)
+    """
+    if len(coeffs.shape) != 1:
+        raise ValueError(
+            f"Polynomial coefficients must be 1D array, got shape {coeffs.shape}"
+        )
+    _ = coeffs
+    return ciphertext
+
+
+@_fhe_MOD.simple_op()
+def negate(ciphertext: TensorType) -> TensorType:
+    """Negate encrypted data (unary minus).
+
+    Args:
+        ciphertext: Encrypted data (scalar or 1D vector)
+
+    Returns:
+        Negated ciphertext with same shape and dtype
+
+    Note: Equivalent to multiplying by -1.
+    """
+    return ciphertext
+
+
+@_fhe_MOD.simple_op()
+def square(ciphertext: TensorType) -> TensorType:
+    """Square encrypted data (element-wise).
+
+    Args:
+        ciphertext: Encrypted data (scalar or 1D vector)
+
+    Returns:
+        Squared ciphertext with same shape and dtype
+
+    Note: More efficient than mul(ciphertext, ciphertext) in some FHE schemes.
+    """
+    return ciphertext