{
  "operations": [
    {
      "name": "abs",
      "module": "numpy",
      "mechestim_ref": "me.abs",
      "numpy_ref": "np.abs",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise absolute value; alias for absolute."
    },
    {
      "name": "absolute",
      "module": "numpy",
      "mechestim_ref": "me.absolute",
      "numpy_ref": "np.absolute",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise absolute value."
    },
    {
      "name": "acos",
      "module": "numpy",
      "mechestim_ref": "me.acos",
      "numpy_ref": "np.acos",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arccos (NumPy 2.x)."
    },
    {
      "name": "acosh",
      "module": "numpy",
      "mechestim_ref": "me.acosh",
      "numpy_ref": "np.acosh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arccosh (NumPy 2.x)."
    },
    {
      "name": "add",
      "module": "numpy",
      "mechestim_ref": "me.add",
      "numpy_ref": "np.add",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise addition."
    },
    {
      "name": "all",
      "module": "numpy",
      "mechestim_ref": "me.all",
      "numpy_ref": "np.all",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test whether all array elements are true."
    },
    {
      "name": "allclose",
      "module": "numpy",
      "mechestim_ref": "me.allclose",
      "numpy_ref": "np.allclose",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise tolerance check; cost = numel(a)."
    },
    {
      "name": "amax",
      "module": "numpy",
      "mechestim_ref": "me.amax",
      "numpy_ref": "np.amax",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Maximum value of array (alias for max/numpy.amax)."
    },
    {
      "name": "amin",
      "module": "numpy",
      "mechestim_ref": "me.amin",
      "numpy_ref": "np.amin",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Minimum value of array (alias for min/numpy.amin)."
    },
    {
      "name": "angle",
      "module": "numpy",
      "mechestim_ref": "me.angle",
      "numpy_ref": "np.angle",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return angle of complex argument element-wise."
    },
    {
      "name": "any",
      "module": "numpy",
      "mechestim_ref": "me.any",
      "numpy_ref": "np.any",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test whether any array element is true."
    },
    {
      "name": "append",
      "module": "numpy",
      "mechestim_ref": "me.append",
      "numpy_ref": "np.append",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Append values to end of array."
    },
    {
      "name": "apply_along_axis",
      "module": "numpy",
      "mechestim_ref": "me.apply_along_axis",
      "numpy_ref": "np.apply_along_axis",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Apply function along axis. Not supported."
    },
    {
      "name": "apply_over_axes",
      "module": "numpy",
      "mechestim_ref": "me.apply_over_axes",
      "numpy_ref": "np.apply_over_axes",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Apply function over multiple axes. Not supported."
    },
    {
      "name": "arange",
      "module": "numpy",
      "mechestim_ref": "me.arange",
      "numpy_ref": "np.arange",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return evenly spaced values in given interval."
    },
    {
      "name": "arccos",
      "module": "numpy",
      "mechestim_ref": "me.arccos",
      "numpy_ref": "np.arccos",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse cosine."
    },
    {
      "name": "arccosh",
      "module": "numpy",
      "mechestim_ref": "me.arccosh",
      "numpy_ref": "np.arccosh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse hyperbolic cosine."
    },
    {
      "name": "arcsin",
      "module": "numpy",
      "mechestim_ref": "me.arcsin",
      "numpy_ref": "np.arcsin",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse sine."
    },
    {
      "name": "arcsinh",
      "module": "numpy",
      "mechestim_ref": "me.arcsinh",
      "numpy_ref": "np.arcsinh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse hyperbolic sine."
    },
    {
      "name": "arctan",
      "module": "numpy",
      "mechestim_ref": "me.arctan",
      "numpy_ref": "np.arctan",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse tangent."
    },
    {
      "name": "arctan2",
      "module": "numpy",
      "mechestim_ref": "me.arctan2",
      "numpy_ref": "np.arctan2",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise arctan(y/x) considering quadrant."
    },
    {
      "name": "arctanh",
      "module": "numpy",
      "mechestim_ref": "me.arctanh",
      "numpy_ref": "np.arctanh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise inverse hyperbolic tangent."
    },
    {
      "name": "argmax",
      "module": "numpy",
      "mechestim_ref": "me.argmax",
      "numpy_ref": "np.argmax",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Index of maximum value."
    },
    {
      "name": "argmin",
      "module": "numpy",
      "mechestim_ref": "me.argmin",
      "numpy_ref": "np.argmin",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Index of minimum value."
    },
    {
      "name": "argpartition",
      "module": "numpy",
      "mechestim_ref": "me.argpartition",
      "numpy_ref": "np.argpartition",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Indirect partition; cost = n per slice."
    },
    {
      "name": "argsort",
      "module": "numpy",
      "mechestim_ref": "me.argsort",
      "numpy_ref": "np.argsort",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Indirect sort; cost = n*ceil(log2(n)) per slice."
    },
    {
      "name": "argwhere",
      "module": "numpy",
      "mechestim_ref": "me.argwhere",
      "numpy_ref": "np.argwhere",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Find indices of non-zero elements."
    },
    {
      "name": "around",
      "module": "numpy",
      "mechestim_ref": "me.around",
      "numpy_ref": "np.around",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for round."
    },
    {
      "name": "array",
      "module": "numpy",
      "mechestim_ref": "me.array",
      "numpy_ref": "np.array",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create array from data."
    },
    {
      "name": "array2string",
      "module": "numpy",
      "mechestim_ref": "me.array2string",
      "numpy_ref": "np.array2string",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return string representation of array. Not supported."
    },
    {
      "name": "array_equal",
      "module": "numpy",
      "mechestim_ref": "me.array_equal",
      "numpy_ref": "np.array_equal",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise equality; cost = numel(a)."
    },
    {
      "name": "array_equiv",
      "module": "numpy",
      "mechestim_ref": "me.array_equiv",
      "numpy_ref": "np.array_equiv",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise equivalence; cost = numel(a)."
    },
    {
      "name": "array_repr",
      "module": "numpy",
      "mechestim_ref": "me.array_repr",
      "numpy_ref": "np.array_repr",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return string representation of array. Not supported."
    },
    {
      "name": "array_split",
      "module": "numpy",
      "mechestim_ref": "me.array_split",
      "numpy_ref": "np.array_split",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Split array into sub-arrays (possibly unequal)."
    },
    {
      "name": "array_str",
      "module": "numpy",
      "mechestim_ref": "me.array_str",
      "numpy_ref": "np.array_str",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return string representation of data in array. Not supported."
    },
    {
      "name": "asarray",
      "module": "numpy",
      "mechestim_ref": "me.asarray",
      "numpy_ref": "np.asarray",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Convert input to array."
    },
    {
      "name": "asarray_chkfinite",
      "module": "numpy",
      "mechestim_ref": "me.asarray_chkfinite",
      "numpy_ref": "np.asarray_chkfinite",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Convert to array, raising if NaN or inf."
    },
    {
      "name": "asin",
      "module": "numpy",
      "mechestim_ref": "me.asin",
      "numpy_ref": "np.asin",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arcsin (NumPy 2.x)."
    },
    {
      "name": "asinh",
      "module": "numpy",
      "mechestim_ref": "me.asinh",
      "numpy_ref": "np.asinh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arcsinh (NumPy 2.x)."
    },
    {
      "name": "asmatrix",
      "module": "numpy",
      "mechestim_ref": "me.asmatrix",
      "numpy_ref": "np.asmatrix",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Interpret input as matrix (deprecated). Not supported."
    },
    {
      "name": "astype",
      "module": "numpy",
      "mechestim_ref": "me.astype",
      "numpy_ref": "np.astype",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Cast array to specified type."
    },
    {
      "name": "atan",
      "module": "numpy",
      "mechestim_ref": "me.atan",
      "numpy_ref": "np.atan",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arctan (NumPy 2.x)."
    },
    {
      "name": "atan2",
      "module": "numpy",
      "mechestim_ref": "me.atan2",
      "numpy_ref": "np.atan2",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arctan2 (NumPy 2.x)."
    },
    {
      "name": "atanh",
      "module": "numpy",
      "mechestim_ref": "me.atanh",
      "numpy_ref": "np.atanh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for arctanh (NumPy 2.x)."
    },
    {
      "name": "atleast_1d",
      "module": "numpy",
      "mechestim_ref": "me.atleast_1d",
      "numpy_ref": "np.atleast_1d",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "View inputs as arrays with at least one dimension."
    },
    {
      "name": "atleast_2d",
      "module": "numpy",
      "mechestim_ref": "me.atleast_2d",
      "numpy_ref": "np.atleast_2d",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "View inputs as arrays with at least two dimensions."
    },
    {
      "name": "atleast_3d",
      "module": "numpy",
      "mechestim_ref": "me.atleast_3d",
      "numpy_ref": "np.atleast_3d",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "View inputs as arrays with at least three dimensions."
    },
    {
      "name": "average",
      "module": "numpy",
      "mechestim_ref": "me.average",
      "numpy_ref": "np.average",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Weighted average of array elements."
    },
    {
      "name": "bartlett",
      "module": "mechestim._window",
      "mechestim_ref": "me.bartlett",
      "numpy_ref": "np.bartlett",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Bartlett window. Cost: n (one linear eval per sample)."
    },
    {
      "name": "base_repr",
      "module": "numpy",
      "mechestim_ref": "me.base_repr",
      "numpy_ref": "np.base_repr",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return string representation of number in given base."
    },
    {
      "name": "binary_repr",
      "module": "numpy",
      "mechestim_ref": "me.binary_repr",
      "numpy_ref": "np.binary_repr",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return binary string representation of the input number."
    },
    {
      "name": "bincount",
      "module": "numpy",
      "mechestim_ref": "me.bincount",
      "numpy_ref": "np.bincount",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Integer counting; cost = numel(x)."
    },
    {
      "name": "bitwise_and",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_and",
      "numpy_ref": "np.bitwise_and",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise bitwise AND."
    },
    {
      "name": "bitwise_count",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_count",
      "numpy_ref": "np.bitwise_count",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Count set bits element-wise (popcount)."
    },
    {
      "name": "bitwise_invert",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_invert",
      "numpy_ref": "np.bitwise_invert",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise bitwise invert (alias for bitwise_not)."
    },
    {
      "name": "bitwise_left_shift",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_left_shift",
      "numpy_ref": "np.bitwise_left_shift",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise left bit shift."
    },
    {
      "name": "bitwise_not",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_not",
      "numpy_ref": "np.bitwise_not",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise bitwise NOT."
    },
    {
      "name": "bitwise_or",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_or",
      "numpy_ref": "np.bitwise_or",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise bitwise OR."
    },
    {
      "name": "bitwise_right_shift",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_right_shift",
      "numpy_ref": "np.bitwise_right_shift",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise right bit shift."
    },
    {
      "name": "bitwise_xor",
      "module": "numpy",
      "mechestim_ref": "me.bitwise_xor",
      "numpy_ref": "np.bitwise_xor",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise bitwise XOR."
    },
    {
      "name": "blackman",
      "module": "mechestim._window",
      "mechestim_ref": "me.blackman",
      "numpy_ref": "np.blackman",
      "category": "counted_custom",
      "cost_formula": "3n",
      "cost_formula_latex": "$3n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Blackman window. Cost: 3*n (three cosine terms per sample)."
    },
    {
      "name": "block",
      "module": "numpy",
      "mechestim_ref": "me.block",
      "numpy_ref": "np.block",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Assemble ndarray from nested list of blocks."
    },
    {
      "name": "bmat",
      "module": "numpy",
      "mechestim_ref": "me.bmat",
      "numpy_ref": "np.bmat",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Build matrix from nested list of matrices."
    },
    {
      "name": "broadcast_arrays",
      "module": "numpy",
      "mechestim_ref": "me.broadcast_arrays",
      "numpy_ref": "np.broadcast_arrays",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Broadcast arrays against each other."
    },
    {
      "name": "broadcast_shapes",
      "module": "numpy",
      "mechestim_ref": "me.broadcast_shapes",
      "numpy_ref": "np.broadcast_shapes",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Compute broadcast shape from input shapes."
    },
    {
      "name": "broadcast_to",
      "module": "numpy",
      "mechestim_ref": "me.broadcast_to",
      "numpy_ref": "np.broadcast_to",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Broadcast array to new shape."
    },
    {
      "name": "busday_count",
      "module": "numpy",
      "mechestim_ref": "me.busday_count",
      "numpy_ref": "np.busday_count",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Count valid days between begindate and enddate. Not supported."
    },
    {
      "name": "busday_offset",
      "module": "numpy",
      "mechestim_ref": "me.busday_offset",
      "numpy_ref": "np.busday_offset",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Apply offset to dates subject to valid day rules. Not supported."
    },
    {
      "name": "can_cast",
      "module": "numpy",
      "mechestim_ref": "me.can_cast",
      "numpy_ref": "np.can_cast",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Returns True if cast is safe."
    },
    {
      "name": "cbrt",
      "module": "numpy",
      "mechestim_ref": "me.cbrt",
      "numpy_ref": "np.cbrt",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise cube root."
    },
    {
      "name": "ceil",
      "module": "numpy",
      "mechestim_ref": "me.ceil",
      "numpy_ref": "np.ceil",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise ceiling."
    },
    {
      "name": "choose",
      "module": "numpy",
      "mechestim_ref": "me.choose",
      "numpy_ref": "np.choose",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct array from index array and choices."
    },
    {
      "name": "clip",
      "module": "numpy",
      "mechestim_ref": "me.clip",
      "numpy_ref": "np.clip",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Clip array to [a_min, a_max] element-wise."
    },
    {
      "name": "column_stack",
      "module": "numpy",
      "mechestim_ref": "me.column_stack",
      "numpy_ref": "np.column_stack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Stack 1-D arrays as columns into 2-D array."
    },
    {
      "name": "common_type",
      "module": "numpy",
      "mechestim_ref": "me.common_type",
      "numpy_ref": "np.common_type",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return scalar type common to all input arrays."
    },
    {
      "name": "compress",
      "module": "numpy",
      "mechestim_ref": "me.compress",
      "numpy_ref": "np.compress",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return selected slices along axis."
    },
    {
      "name": "concat",
      "module": "numpy",
      "mechestim_ref": "me.concat",
      "numpy_ref": "np.concat",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Join arrays along axis (NumPy 2.x array API alias for concatenate)."
    },
    {
      "name": "concatenate",
      "module": "numpy",
      "mechestim_ref": "me.concatenate",
      "numpy_ref": "np.concatenate",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Join arrays along axis."
    },
    {
      "name": "conj",
      "module": "numpy",
      "mechestim_ref": "me.conj",
      "numpy_ref": "np.conj",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Complex conjugate element-wise."
    },
    {
      "name": "conjugate",
      "module": "numpy",
      "mechestim_ref": "me.conjugate",
      "numpy_ref": "np.conjugate",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Complex conjugate element-wise."
    },
    {
      "name": "convolve",
      "module": "numpy",
      "mechestim_ref": "me.convolve",
      "numpy_ref": "np.convolve",
      "category": "counted_custom",
      "cost_formula": "n * m",
      "cost_formula_latex": "$n \\cdot m$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "1-D discrete convolution."
    },
    {
      "name": "copy",
      "module": "numpy",
      "mechestim_ref": "me.copy",
      "numpy_ref": "np.copy",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return array copy."
    },
    {
      "name": "copysign",
      "module": "numpy",
      "mechestim_ref": "me.copysign",
      "numpy_ref": "np.copysign",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Copy sign of x2 to magnitude of x1 element-wise."
    },
    {
      "name": "copyto",
      "module": "numpy",
      "mechestim_ref": "me.copyto",
      "numpy_ref": "np.copyto",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Copy values from src to dst array."
    },
    {
      "name": "corrcoef",
      "module": "numpy",
      "mechestim_ref": "me.corrcoef",
      "numpy_ref": "np.corrcoef",
      "category": "counted_custom",
      "cost_formula": "n^2 * m",
      "cost_formula_latex": "$n^2 \\cdot m$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Pearson correlation coefficients."
    },
    {
      "name": "correlate",
      "module": "numpy",
      "mechestim_ref": "me.correlate",
      "numpy_ref": "np.correlate",
      "category": "counted_custom",
      "cost_formula": "n * m",
      "cost_formula_latex": "$n \\cdot m$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "1-D cross-correlation."
    },
    {
      "name": "cos",
      "module": "numpy",
      "mechestim_ref": "me.cos",
      "numpy_ref": "np.cos",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise cosine."
    },
    {
      "name": "cosh",
      "module": "numpy",
      "mechestim_ref": "me.cosh",
      "numpy_ref": "np.cosh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise hyperbolic cosine."
    },
    {
      "name": "count_nonzero",
      "module": "numpy",
      "mechestim_ref": "me.count_nonzero",
      "numpy_ref": "np.count_nonzero",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Count non-zero elements."
    },
    {
      "name": "cov",
      "module": "numpy",
      "mechestim_ref": "me.cov",
      "numpy_ref": "np.cov",
      "category": "counted_custom",
      "cost_formula": "n^2 * m",
      "cost_formula_latex": "$n^2 \\cdot m$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Covariance matrix."
    },
    {
      "name": "cross",
      "module": "numpy",
      "mechestim_ref": "me.cross",
      "numpy_ref": "np.cross",
      "category": "counted_custom",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cross product of two 3-D vectors."
    },
    {
      "name": "cumprod",
      "module": "numpy",
      "mechestim_ref": "me.cumprod",
      "numpy_ref": "np.cumprod",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative product of array elements."
    },
    {
      "name": "cumsum",
      "module": "numpy",
      "mechestim_ref": "me.cumsum",
      "numpy_ref": "np.cumsum",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative sum of array elements."
    },
    {
      "name": "cumulative_prod",
      "module": "numpy",
      "mechestim_ref": "me.cumulative_prod",
      "numpy_ref": "np.cumulative_prod",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative product (NumPy 2.x array API)."
    },
    {
      "name": "cumulative_sum",
      "module": "numpy",
      "mechestim_ref": "me.cumulative_sum",
      "numpy_ref": "np.cumulative_sum",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative sum (NumPy 2.x array API)."
    },
    {
      "name": "datetime_as_string",
      "module": "numpy",
      "mechestim_ref": "me.datetime_as_string",
      "numpy_ref": "np.datetime_as_string",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Convert datetime array to string representation. Not supported."
    },
    {
      "name": "datetime_data",
      "module": "numpy",
      "mechestim_ref": "me.datetime_data",
      "numpy_ref": "np.datetime_data",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Get information about the step size of datetime dtype. Not supported."
    },
    {
      "name": "deg2rad",
      "module": "numpy",
      "mechestim_ref": "me.deg2rad",
      "numpy_ref": "np.deg2rad",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for radians."
    },
    {
      "name": "degrees",
      "module": "numpy",
      "mechestim_ref": "me.degrees",
      "numpy_ref": "np.degrees",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Convert radians to degrees element-wise."
    },
    {
      "name": "delete",
      "module": "numpy",
      "mechestim_ref": "me.delete",
      "numpy_ref": "np.delete",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return array with sub-arrays deleted along axis."
    },
    {
      "name": "diag",
      "module": "numpy",
      "mechestim_ref": "me.diag",
      "numpy_ref": "np.diag",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Extract diagonal or construct diagonal array."
    },
    {
      "name": "diag_indices",
      "module": "numpy",
      "mechestim_ref": "me.diag_indices",
      "numpy_ref": "np.diag_indices",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return indices to access main diagonal of n-D array."
    },
    {
      "name": "diag_indices_from",
      "module": "numpy",
      "mechestim_ref": "me.diag_indices_from",
      "numpy_ref": "np.diag_indices_from",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return indices to access main diagonal of given array."
    },
    {
      "name": "diagflat",
      "module": "numpy",
      "mechestim_ref": "me.diagflat",
      "numpy_ref": "np.diagflat",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create diagonal array from flattened input."
    },
    {
      "name": "diagonal",
      "module": "numpy",
      "mechestim_ref": "me.diagonal",
      "numpy_ref": "np.diagonal",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return specified diagonals."
    },
    {
      "name": "diff",
      "module": "numpy",
      "mechestim_ref": "me.diff",
      "numpy_ref": "np.diff",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "n-th discrete difference along axis."
    },
    {
      "name": "digitize",
      "module": "numpy",
      "mechestim_ref": "me.digitize",
      "numpy_ref": "np.digitize",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Bin search; cost = n*ceil(log2(bins))."
    },
    {
      "name": "divide",
      "module": "numpy",
      "mechestim_ref": "me.divide",
      "numpy_ref": "np.divide",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise true division."
    },
    {
      "name": "divmod",
      "module": "numpy",
      "mechestim_ref": "me.divmod",
      "numpy_ref": "np.divmod",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise (quotient, remainder) tuple."
    },
    {
      "name": "dot",
      "module": "numpy",
      "mechestim_ref": "me.dot",
      "numpy_ref": "np.dot",
      "category": "counted_custom",
      "cost_formula": "2 * m * k * n",
      "cost_formula_latex": "$2 \\cdot m \\cdot k \\cdot n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Dot product; cost = 2*M*N*K for matrix multiply."
    },
    {
      "name": "dsplit",
      "module": "numpy",
      "mechestim_ref": "me.dsplit",
      "numpy_ref": "np.dsplit",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Split array into multiple sub-arrays depth-wise."
    },
    {
      "name": "dstack",
      "module": "numpy",
      "mechestim_ref": "me.dstack",
      "numpy_ref": "np.dstack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Stack arrays depth-wise (along third axis)."
    },
    {
      "name": "ediff1d",
      "module": "numpy",
      "mechestim_ref": "me.ediff1d",
      "numpy_ref": "np.ediff1d",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Differences between consecutive elements."
    },
    {
      "name": "einsum",
      "module": "numpy",
      "mechestim_ref": "me.einsum",
      "numpy_ref": "np.einsum",
      "category": "counted_custom",
      "cost_formula": "op_factor * product of all index dims",
      "cost_formula_latex": "$\\text{op\\_factor} \\cdot \\prod_i d_i$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Generalized Einstein summation."
    },
    {
      "name": "einsum_path",
      "module": "numpy",
      "mechestim_ref": "me.einsum_path",
      "numpy_ref": "np.einsum_path",
      "category": "counted_custom",
      "cost_formula": "0 (planning only)",
      "cost_formula_latex": "$0$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Optimize einsum contraction path (no numeric output)."
    },
    {
      "name": "empty",
      "module": "numpy",
      "mechestim_ref": "me.empty",
      "numpy_ref": "np.empty",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Uninitialized array allocation."
    },
    {
      "name": "empty_like",
      "module": "numpy",
      "mechestim_ref": "me.empty_like",
      "numpy_ref": "np.empty_like",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Uninitialized array with same shape/type as input."
    },
    {
      "name": "equal",
      "module": "numpy",
      "mechestim_ref": "me.equal",
      "numpy_ref": "np.equal",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 == x2."
    },
    {
      "name": "exp",
      "module": "numpy",
      "mechestim_ref": "me.exp",
      "numpy_ref": "np.exp",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise e^x."
    },
    {
      "name": "exp2",
      "module": "numpy",
      "mechestim_ref": "me.exp2",
      "numpy_ref": "np.exp2",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise 2^x."
    },
    {
      "name": "expand_dims",
      "module": "numpy",
      "mechestim_ref": "me.expand_dims",
      "numpy_ref": "np.expand_dims",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Insert new size-1 axis."
    },
    {
      "name": "expm1",
      "module": "numpy",
      "mechestim_ref": "me.expm1",
      "numpy_ref": "np.expm1",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise e^x - 1 (accurate near zero)."
    },
    {
      "name": "extract",
      "module": "numpy",
      "mechestim_ref": "me.extract",
      "numpy_ref": "np.extract",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return elements satisfying condition."
    },
    {
      "name": "eye",
      "module": "numpy",
      "mechestim_ref": "me.eye",
      "numpy_ref": "np.eye",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create identity matrix."
    },
    {
      "name": "fabs",
      "module": "numpy",
      "mechestim_ref": "me.fabs",
      "numpy_ref": "np.fabs",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise absolute value (always float)."
    },
    {
      "name": "fft.fft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.fft",
      "numpy_ref": "np.fft.fft",
      "category": "counted_custom",
      "cost_formula": "5n * ceil(log2(n))",
      "cost_formula_latex": "$5n \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "1-D complex FFT. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.fft2",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.fft2",
      "numpy_ref": "np.fft.fft2",
      "category": "counted_custom",
      "cost_formula": "5N * ceil(log2(N))",
      "cost_formula_latex": "$5N \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "2-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.fftfreq",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.fftfreq",
      "numpy_ref": "np.fft.fftfreq",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "FFT sample frequencies. No arithmetic; returns index array."
    },
    {
      "name": "fft.fftn",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.fftn",
      "numpy_ref": "np.fft.fftn",
      "category": "counted_custom",
      "cost_formula": "5N * ceil(log2(N))",
      "cost_formula_latex": "$5N \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "N-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.fftshift",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.fftshift",
      "numpy_ref": "np.fft.fftshift",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Shift zero-frequency component to center. No arithmetic; index reordering only."
    },
    {
      "name": "fft.hfft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.hfft",
      "numpy_ref": "np.fft.hfft",
      "category": "counted_custom",
      "cost_formula": "5n * ceil(log2(n))",
      "cost_formula_latex": "$5n \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "FFT of Hermitian-symmetric signal. Cost: 5*n_out*ceil(log2(n_out)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.ifft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.ifft",
      "numpy_ref": "np.fft.ifft",
      "category": "counted_custom",
      "cost_formula": "5n * ceil(log2(n))",
      "cost_formula_latex": "$5n \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse 1-D complex FFT. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.ifft2",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.ifft2",
      "numpy_ref": "np.fft.ifft2",
      "category": "counted_custom",
      "cost_formula": "5N * ceil(log2(N))",
      "cost_formula_latex": "$5N \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse 2-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.ifftn",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.ifftn",
      "numpy_ref": "np.fft.ifftn",
      "category": "counted_custom",
      "cost_formula": "5N * ceil(log2(N))",
      "cost_formula_latex": "$5N \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse N-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.ifftshift",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.ifftshift",
      "numpy_ref": "np.fft.ifftshift",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse of fftshift. No arithmetic; index reordering only."
    },
    {
      "name": "fft.ihfft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.ihfft",
      "numpy_ref": "np.fft.ihfft",
      "category": "counted_custom",
      "cost_formula": "5n * ceil(log2(n))",
      "cost_formula_latex": "$5n \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse FFT of Hermitian signal. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.irfft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.irfft",
      "numpy_ref": "np.fft.irfft",
      "category": "counted_custom",
      "cost_formula": "5(n/2) * ceil(log2(n))",
      "cost_formula_latex": "$5(n/2) \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse 1-D real FFT. Cost: 5*(n//2)*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.irfft2",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.irfft2",
      "numpy_ref": "np.fft.irfft2",
      "category": "counted_custom",
      "cost_formula": "5(N/2) * ceil(log2(N))",
      "cost_formula_latex": "$5(N/2) \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse 2-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.irfftn",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.irfftn",
      "numpy_ref": "np.fft.irfftn",
      "category": "counted_custom",
      "cost_formula": "5(N/2) * ceil(log2(N))",
      "cost_formula_latex": "$5(N/2) \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inverse N-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.rfft",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.rfft",
      "numpy_ref": "np.fft.rfft",
      "category": "counted_custom",
      "cost_formula": "5(n/2) * ceil(log2(n))",
      "cost_formula_latex": "$5(n/2) \\cdot \\lceil\\log_2 n\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "1-D real FFT. Cost: 5*(n//2)*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.rfft2",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.rfft2",
      "numpy_ref": "np.fft.rfft2",
      "category": "counted_custom",
      "cost_formula": "5(N/2) * ceil(log2(N))",
      "cost_formula_latex": "$5(N/2) \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "2-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fft.rfftfreq",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.rfftfreq",
      "numpy_ref": "np.fft.rfftfreq",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Real FFT sample frequencies. No arithmetic; returns index array."
    },
    {
      "name": "fft.rfftn",
      "module": "numpy.fft",
      "mechestim_ref": "me.fft.rfftn",
      "numpy_ref": "np.fft.rfftn",
      "category": "counted_custom",
      "cost_formula": "5(N/2) * ceil(log2(N))",
      "cost_formula_latex": "$5(N/2) \\cdot \\lceil\\log_2 N\\rceil$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "N-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 \u00a71.4)."
    },
    {
      "name": "fill_diagonal",
      "module": "numpy",
      "mechestim_ref": "me.fill_diagonal",
      "numpy_ref": "np.fill_diagonal",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Fill main diagonal of given array."
    },
    {
      "name": "fix",
      "module": "numpy",
      "mechestim_ref": "me.fix",
      "numpy_ref": "np.fix",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Round toward zero element-wise (alias for trunc)."
    },
    {
      "name": "flatnonzero",
      "module": "numpy",
      "mechestim_ref": "me.flatnonzero",
      "numpy_ref": "np.flatnonzero",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return indices of non-zero elements in flattened array."
    },
    {
      "name": "flip",
      "module": "numpy",
      "mechestim_ref": "me.flip",
      "numpy_ref": "np.flip",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Reverse order of elements along axis."
    },
    {
      "name": "fliplr",
      "module": "numpy",
      "mechestim_ref": "me.fliplr",
      "numpy_ref": "np.fliplr",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Flip array left-right."
    },
    {
      "name": "flipud",
      "module": "numpy",
      "mechestim_ref": "me.flipud",
      "numpy_ref": "np.flipud",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Flip array up-down."
    },
    {
      "name": "float_power",
      "module": "numpy",
      "mechestim_ref": "me.float_power",
      "numpy_ref": "np.float_power",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise exponentiation in float64."
    },
    {
      "name": "floor",
      "module": "numpy",
      "mechestim_ref": "me.floor",
      "numpy_ref": "np.floor",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise floor."
    },
    {
      "name": "floor_divide",
      "module": "numpy",
      "mechestim_ref": "me.floor_divide",
      "numpy_ref": "np.floor_divide",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise floor division."
    },
    {
      "name": "fmax",
      "module": "numpy",
      "mechestim_ref": "me.fmax",
      "numpy_ref": "np.fmax",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise maximum ignoring NaN."
    },
    {
      "name": "fmin",
      "module": "numpy",
      "mechestim_ref": "me.fmin",
      "numpy_ref": "np.fmin",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise minimum ignoring NaN."
    },
    {
      "name": "fmod",
      "module": "numpy",
      "mechestim_ref": "me.fmod",
      "numpy_ref": "np.fmod",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise C-style fmod (remainder toward zero)."
    },
    {
      "name": "format_float_positional",
      "module": "numpy",
      "mechestim_ref": "me.format_float_positional",
      "numpy_ref": "np.format_float_positional",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Format floating point scalar as decimal string. Not supported."
    },
    {
      "name": "format_float_scientific",
      "module": "numpy",
      "mechestim_ref": "me.format_float_scientific",
      "numpy_ref": "np.format_float_scientific",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Format floating point scalar as scientific notation. Not supported."
    },
    {
      "name": "frexp",
      "module": "numpy",
      "mechestim_ref": "me.frexp",
      "numpy_ref": "np.frexp",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Decompose x into mantissa and exponent element-wise."
    },
    {
      "name": "from_dlpack",
      "module": "numpy",
      "mechestim_ref": "me.from_dlpack",
      "numpy_ref": "np.from_dlpack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create ndarray from DLPack object (zero-copy)."
    },
    {
      "name": "frombuffer",
      "module": "numpy",
      "mechestim_ref": "me.frombuffer",
      "numpy_ref": "np.frombuffer",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Interpret buffer as 1-D array."
    },
    {
      "name": "fromfile",
      "module": "numpy",
      "mechestim_ref": "me.fromfile",
      "numpy_ref": "np.fromfile",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct array from binary/text file."
    },
    {
      "name": "fromfunction",
      "module": "numpy",
      "mechestim_ref": "me.fromfunction",
      "numpy_ref": "np.fromfunction",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct array by executing function over each coordinate."
    },
    {
      "name": "fromiter",
      "module": "numpy",
      "mechestim_ref": "me.fromiter",
      "numpy_ref": "np.fromiter",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create array from an iterable."
    },
    {
      "name": "frompyfunc",
      "module": "numpy",
      "mechestim_ref": "me.frompyfunc",
      "numpy_ref": "np.frompyfunc",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Take arbitrary Python function and return NumPy ufunc. Not supported."
    },
    {
      "name": "fromregex",
      "module": "numpy",
      "mechestim_ref": "me.fromregex",
      "numpy_ref": "np.fromregex",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct array from text file using regex."
    },
    {
      "name": "fromstring",
      "module": "numpy",
      "mechestim_ref": "me.fromstring",
      "numpy_ref": "np.fromstring",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create 1-D array from string data."
    },
    {
      "name": "full",
      "module": "numpy",
      "mechestim_ref": "me.full",
      "numpy_ref": "np.full",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create array filled with scalar value."
    },
    {
      "name": "full_like",
      "module": "numpy",
      "mechestim_ref": "me.full_like",
      "numpy_ref": "np.full_like",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Array filled with scalar, same shape/type as input."
    },
    {
      "name": "gcd",
      "module": "numpy",
      "mechestim_ref": "me.gcd",
      "numpy_ref": "np.gcd",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise greatest common divisor."
    },
    {
      "name": "genfromtxt",
      "module": "numpy",
      "mechestim_ref": "me.genfromtxt",
      "numpy_ref": "np.genfromtxt",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Load data from text file with missing values. Not supported."
    },
    {
      "name": "geomspace",
      "module": "numpy",
      "mechestim_ref": "me.geomspace",
      "numpy_ref": "np.geomspace",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Geometric-spaced generation; cost = num."
    },
    {
      "name": "get_include",
      "module": "numpy",
      "mechestim_ref": "me.get_include",
      "numpy_ref": "np.get_include",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return directory containing NumPy C header files. Not supported."
    },
    {
      "name": "getbufsize",
      "module": "numpy",
      "mechestim_ref": "me.getbufsize",
      "numpy_ref": "np.getbufsize",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return size of buffer used in ufuncs. Not supported."
    },
    {
      "name": "geterr",
      "module": "numpy",
      "mechestim_ref": "me.geterr",
      "numpy_ref": "np.geterr",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Get current way of handling floating-point errors. Not supported."
    },
    {
      "name": "geterrcall",
      "module": "numpy",
      "mechestim_ref": "me.geterrcall",
      "numpy_ref": "np.geterrcall",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Return current callback function for floating-point errors. Not supported."
    },
    {
      "name": "gradient",
      "module": "numpy",
      "mechestim_ref": "me.gradient",
      "numpy_ref": "np.gradient",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Gradient using central differences."
    },
    {
      "name": "greater",
      "module": "numpy",
      "mechestim_ref": "me.greater",
      "numpy_ref": "np.greater",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 > x2."
    },
    {
      "name": "greater_equal",
      "module": "numpy",
      "mechestim_ref": "me.greater_equal",
      "numpy_ref": "np.greater_equal",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 >= x2."
    },
    {
      "name": "hamming",
      "module": "mechestim._window",
      "mechestim_ref": "me.hamming",
      "numpy_ref": "np.hamming",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Hamming window. Cost: n (one cosine per sample)."
    },
    {
      "name": "hanning",
      "module": "mechestim._window",
      "mechestim_ref": "me.hanning",
      "numpy_ref": "np.hanning",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Hanning window. Cost: n (one cosine per sample)."
    },
    {
      "name": "heaviside",
      "module": "numpy",
      "mechestim_ref": "me.heaviside",
      "numpy_ref": "np.heaviside",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Heaviside step function element-wise."
    },
    {
      "name": "histogram",
      "module": "numpy",
      "mechestim_ref": "me.histogram",
      "numpy_ref": "np.histogram",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Binning; cost = n*ceil(log2(bins))."
    },
    {
      "name": "histogram2d",
      "module": "numpy",
      "mechestim_ref": "me.histogram2d",
      "numpy_ref": "np.histogram2d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "2D binning; cost = n*(ceil(log2(bx))+ceil(log2(by)))."
    },
    {
      "name": "histogram_bin_edges",
      "module": "numpy",
      "mechestim_ref": "me.histogram_bin_edges",
      "numpy_ref": "np.histogram_bin_edges",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Bin edge computation; cost = numel(a)."
    },
    {
      "name": "histogramdd",
      "module": "numpy",
      "mechestim_ref": "me.histogramdd",
      "numpy_ref": "np.histogramdd",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "ND binning; cost = n*sum(ceil(log2(b_i)))."
    },
    {
      "name": "hsplit",
      "module": "numpy",
      "mechestim_ref": "me.hsplit",
      "numpy_ref": "np.hsplit",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Split array into columns."
    },
    {
      "name": "hstack",
      "module": "numpy",
      "mechestim_ref": "me.hstack",
      "numpy_ref": "np.hstack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Stack arrays horizontally."
    },
    {
      "name": "hypot",
      "module": "numpy",
      "mechestim_ref": "me.hypot",
      "numpy_ref": "np.hypot",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise Euclidean norm sqrt(x1^2 + x2^2)."
    },
    {
      "name": "i0",
      "module": "numpy",
      "mechestim_ref": "me.i0",
      "numpy_ref": "np.i0",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Modified Bessel function of order 0, element-wise."
    },
    {
      "name": "identity",
      "module": "numpy",
      "mechestim_ref": "me.identity",
      "numpy_ref": "np.identity",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create square identity matrix."
    },
    {
      "name": "imag",
      "module": "numpy",
      "mechestim_ref": "me.imag",
      "numpy_ref": "np.imag",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return imaginary part of complex array."
    },
    {
      "name": "in1d",
      "module": "numpy",
      "mechestim_ref": "me.in1d",
      "numpy_ref": "np.in1d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Set membership; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "indices",
      "module": "numpy",
      "mechestim_ref": "me.indices",
      "numpy_ref": "np.indices",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return array representing indices of a grid."
    },
    {
      "name": "inner",
      "module": "numpy",
      "mechestim_ref": "me.inner",
      "numpy_ref": "np.inner",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Inner product; cost = 2*N for 1-D, 2*N*M for n-D."
    },
    {
      "name": "insert",
      "module": "numpy",
      "mechestim_ref": "me.insert",
      "numpy_ref": "np.insert",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Insert values along axis before given indices."
    },
    {
      "name": "interp",
      "module": "numpy",
      "mechestim_ref": "me.interp",
      "numpy_ref": "np.interp",
      "category": "counted_custom",
      "cost_formula": "n * log(m)",
      "cost_formula_latex": "$n \\cdot \\log m$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "1-D linear interpolation."
    },
    {
      "name": "intersect1d",
      "module": "numpy",
      "mechestim_ref": "me.intersect1d",
      "numpy_ref": "np.intersect1d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Set intersection; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "invert",
      "module": "numpy",
      "mechestim_ref": "me.invert",
      "numpy_ref": "np.invert",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Bitwise NOT element-wise."
    },
    {
      "name": "is_busday",
      "module": "numpy",
      "mechestim_ref": "me.is_busday",
      "numpy_ref": "np.is_busday",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Calculates which of given dates are valid days. Not supported."
    },
    {
      "name": "isclose",
      "module": "numpy",
      "mechestim_ref": "me.isclose",
      "numpy_ref": "np.isclose",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise approximate equality test."
    },
    {
      "name": "iscomplex",
      "module": "numpy",
      "mechestim_ref": "me.iscomplex",
      "numpy_ref": "np.iscomplex",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test if element is complex element-wise."
    },
    {
      "name": "iscomplexobj",
      "module": "numpy",
      "mechestim_ref": "me.iscomplexobj",
      "numpy_ref": "np.iscomplexobj",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if input is a complex type or array."
    },
    {
      "name": "isdtype",
      "module": "numpy",
      "mechestim_ref": "me.isdtype",
      "numpy_ref": "np.isdtype",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if array or dtype is of specified kind (NumPy 2.x)."
    },
    {
      "name": "isfinite",
      "module": "numpy",
      "mechestim_ref": "me.isfinite",
      "numpy_ref": "np.isfinite",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Test for finite values element-wise."
    },
    {
      "name": "isfortran",
      "module": "numpy",
      "mechestim_ref": "me.isfortran",
      "numpy_ref": "np.isfortran",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if array is Fortran contiguous."
    },
    {
      "name": "isin",
      "module": "numpy",
      "mechestim_ref": "me.isin",
      "numpy_ref": "np.isin",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Set membership; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "isinf",
      "module": "numpy",
      "mechestim_ref": "me.isinf",
      "numpy_ref": "np.isinf",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Test for infinity element-wise."
    },
    {
      "name": "isnan",
      "module": "numpy",
      "mechestim_ref": "me.isnan",
      "numpy_ref": "np.isnan",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Test for NaN element-wise."
    },
    {
      "name": "isnat",
      "module": "numpy",
      "mechestim_ref": "me.isnat",
      "numpy_ref": "np.isnat",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test for NaT (not-a-time) element-wise."
    },
    {
      "name": "isneginf",
      "module": "numpy",
      "mechestim_ref": "me.isneginf",
      "numpy_ref": "np.isneginf",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test for negative infinity element-wise."
    },
    {
      "name": "isposinf",
      "module": "numpy",
      "mechestim_ref": "me.isposinf",
      "numpy_ref": "np.isposinf",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test for positive infinity element-wise."
    },
    {
      "name": "isreal",
      "module": "numpy",
      "mechestim_ref": "me.isreal",
      "numpy_ref": "np.isreal",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Test if element is real (imag == 0) element-wise."
    },
    {
      "name": "isrealobj",
      "module": "numpy",
      "mechestim_ref": "me.isrealobj",
      "numpy_ref": "np.isrealobj",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if x is a not complex type or array."
    },
    {
      "name": "isscalar",
      "module": "numpy",
      "mechestim_ref": "me.isscalar",
      "numpy_ref": "np.isscalar",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if input is a scalar."
    },
    {
      "name": "issubdtype",
      "module": "numpy",
      "mechestim_ref": "me.issubdtype",
      "numpy_ref": "np.issubdtype",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if first argument is lower in type hierarchy."
    },
    {
      "name": "iterable",
      "module": "numpy",
      "mechestim_ref": "me.iterable",
      "numpy_ref": "np.iterable",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return True if object is iterable."
    },
    {
      "name": "ix_",
      "module": "numpy",
      "mechestim_ref": "me.ix_",
      "numpy_ref": "np.ix_",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct open mesh from multiple sequences."
    },
    {
      "name": "kaiser",
      "module": "mechestim._window",
      "mechestim_ref": "me.kaiser",
      "numpy_ref": "np.kaiser",
      "category": "counted_custom",
      "cost_formula": "3n",
      "cost_formula_latex": "$3n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Kaiser window. Cost: 3*n (Bessel function eval per sample)."
    },
    {
      "name": "kron",
      "module": "numpy",
      "mechestim_ref": "me.kron",
      "numpy_ref": "np.kron",
      "category": "counted_custom",
      "cost_formula": "m1*m2 * n1*n2",
      "cost_formula_latex": "$m_1 m_2 \\cdot n_1 n_2$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Kronecker product; cost proportional to output size."
    },
    {
      "name": "lcm",
      "module": "numpy",
      "mechestim_ref": "me.lcm",
      "numpy_ref": "np.lcm",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise least common multiple."
    },
    {
      "name": "ldexp",
      "module": "numpy",
      "mechestim_ref": "me.ldexp",
      "numpy_ref": "np.ldexp",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return x1 * 2**x2 element-wise."
    },
    {
      "name": "left_shift",
      "module": "numpy",
      "mechestim_ref": "me.left_shift",
      "numpy_ref": "np.left_shift",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise left bit shift (legacy name)."
    },
    {
      "name": "less",
      "module": "numpy",
      "mechestim_ref": "me.less",
      "numpy_ref": "np.less",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 < x2."
    },
    {
      "name": "less_equal",
      "module": "numpy",
      "mechestim_ref": "me.less_equal",
      "numpy_ref": "np.less_equal",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 <= x2."
    },
    {
      "name": "lexsort",
      "module": "numpy",
      "mechestim_ref": "me.lexsort",
      "numpy_ref": "np.lexsort",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Multi-key sort; cost = k*n*ceil(log2(n))."
    },
    {
      "name": "linalg.cholesky",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.cholesky",
      "numpy_ref": "np.linalg.cholesky",
      "category": "counted_custom",
      "cost_formula": "n^3 / 3",
      "cost_formula_latex": "$n^3 / 3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cholesky decomposition. Cost: $n^3/3$ (Golub & Van Loan \u00a74.2)."
    },
    {
      "name": "linalg.cond",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.cond",
      "numpy_ref": "np.linalg.cond",
      "category": "counted_custom",
      "cost_formula": "m * n * min(m,n)",
      "cost_formula_latex": "$m \\cdot n \\cdot \\min(m,n)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Condition number. Cost: m*n*min(m,n) (via SVD)."
    },
    {
      "name": "linalg.cross",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.cross",
      "numpy_ref": "np.linalg.cross",
      "category": "counted_custom",
      "cost_formula": "delegates to me.cross",
      "cost_formula_latex": "delegates to `cross`",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Delegates to `me.cross` which charges `numel(output)` FLOPs."
    },
    {
      "name": "linalg.det",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.det",
      "numpy_ref": "np.linalg.det",
      "category": "counted_custom",
      "cost_formula": "n^3",
      "cost_formula_latex": "$n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Determinant. Cost: $n^3$ (LU factorization)."
    },
    {
      "name": "linalg.diagonal",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.diagonal",
      "numpy_ref": "np.linalg.diagonal",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "View of diagonal \u2014 delegates to mechestim.diagonal. Cost: 0 FLOPs."
    },
    {
      "name": "linalg.eig",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.eig",
      "numpy_ref": "np.linalg.eig",
      "category": "counted_custom",
      "cost_formula": "10n^3",
      "cost_formula_latex": "$10n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Eigendecomposition. Cost: $10n^3$ (Francis QR, Golub & Van Loan \u00a77.5)."
    },
    {
      "name": "linalg.eigh",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.eigh",
      "numpy_ref": "np.linalg.eigh",
      "category": "counted_custom",
      "cost_formula": "4n^3 / 3",
      "cost_formula_latex": "$4n^3 / 3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Symmetric eigendecomposition. Cost: $(4/3)n^3$ (Golub & Van Loan \u00a78.3)."
    },
    {
      "name": "linalg.eigvals",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.eigvals",
      "numpy_ref": "np.linalg.eigvals",
      "category": "counted_custom",
      "cost_formula": "10n^3",
      "cost_formula_latex": "$10n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Eigenvalues only. Cost: $10n^3$ (same as eig)."
    },
    {
      "name": "linalg.eigvalsh",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.eigvalsh",
      "numpy_ref": "np.linalg.eigvalsh",
      "category": "counted_custom",
      "cost_formula": "4n^3 / 3",
      "cost_formula_latex": "$4n^3 / 3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Symmetric eigenvalues. Cost: $(4/3)n^3$ (same as eigh)."
    },
    {
      "name": "linalg.inv",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.inv",
      "numpy_ref": "np.linalg.inv",
      "category": "counted_custom",
      "cost_formula": "n^3",
      "cost_formula_latex": "$n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix inverse. Cost: $n^3$ (LU + solve)."
    },
    {
      "name": "linalg.lstsq",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.lstsq",
      "numpy_ref": "np.linalg.lstsq",
      "category": "counted_custom",
      "cost_formula": "m * n * min(m,n)",
      "cost_formula_latex": "$m \\cdot n \\cdot \\min(m,n)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Least squares. Cost: m*n*min(m,n) (LAPACK gelsd/SVD)."
    },
    {
      "name": "linalg.matmul",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.matmul",
      "numpy_ref": "np.linalg.matmul",
      "category": "counted_custom",
      "cost_formula": "delegates to me.matmul",
      "cost_formula_latex": "delegates to `matmul`",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Delegates to `me.matmul` which charges `2*m*k*n` FLOPs."
    },
    {
      "name": "linalg.matrix_norm",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.matrix_norm",
      "numpy_ref": "np.linalg.matrix_norm",
      "category": "counted_custom",
      "cost_formula": "depends on ord",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix norm. Cost depends on ord: 2*numel for Frobenius, m*n*min(m,n) for ord=2."
    },
    {
      "name": "linalg.matrix_power",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.matrix_power",
      "numpy_ref": "np.linalg.matrix_power",
      "category": "counted_custom",
      "cost_formula": "log2(k) * n^3",
      "cost_formula_latex": "$\\lfloor\\log_2 k\\rfloor \\cdot n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix power. Cost: $(\\lfloor\\log_2 k\\rfloor + \\text{popcount}(k) - 1) \\cdot n^3$ (exponentiation by squaring)."
    },
    {
      "name": "linalg.matrix_rank",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.matrix_rank",
      "numpy_ref": "np.linalg.matrix_rank",
      "category": "counted_custom",
      "cost_formula": "m * n * min(m,n)",
      "cost_formula_latex": "$m \\cdot n \\cdot \\min(m,n)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix rank. Cost: m*n*min(m,n) (via SVD)."
    },
    {
      "name": "linalg.matrix_transpose",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.matrix_transpose",
      "numpy_ref": "np.linalg.matrix_transpose",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Transpose view \u2014 delegates to mechestim.matrix_transpose. Cost: 0 FLOPs."
    },
    {
      "name": "linalg.multi_dot",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.multi_dot",
      "numpy_ref": "np.linalg.multi_dot",
      "category": "counted_custom",
      "cost_formula": "optimal chain cost",
      "cost_formula_latex": "optimal chain",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Chain matmul. Cost: sum of optimal chain matmul costs (CLRS \u00a715.2)."
    },
    {
      "name": "linalg.norm",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.norm",
      "numpy_ref": "np.linalg.norm",
      "category": "counted_custom",
      "cost_formula": "depends on ord",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Norm. Cost depends on ord: numel for L1/inf, 2*numel for Frobenius, m*n*min(m,n) for ord=2."
    },
    {
      "name": "linalg.outer",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.outer",
      "numpy_ref": "np.linalg.outer",
      "category": "counted_custom",
      "cost_formula": "delegates to me.outer",
      "cost_formula_latex": "delegates to `outer`",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Delegates to `me.outer` which charges `m*n` FLOPs."
    },
    {
      "name": "linalg.pinv",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.pinv",
      "numpy_ref": "np.linalg.pinv",
      "category": "counted_custom",
      "cost_formula": "m * n * min(m,n)",
      "cost_formula_latex": "$m \\cdot n \\cdot \\min(m,n)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Pseudoinverse. Cost: m*n*min(m,n) (via SVD)."
    },
    {
      "name": "linalg.qr",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.qr",
      "numpy_ref": "np.linalg.qr",
      "category": "counted_custom",
      "cost_formula": "2mn^2 - 2n^3/3",
      "cost_formula_latex": "$2mn^2 - 2n^3/3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "QR decomposition. Cost: $2mn^2 - (2/3)n^3$ (Golub & Van Loan \u00a75.2)."
    },
    {
      "name": "linalg.slogdet",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.slogdet",
      "numpy_ref": "np.linalg.slogdet",
      "category": "counted_custom",
      "cost_formula": "n^3",
      "cost_formula_latex": "$n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sign + log determinant. Cost: $n^3$ (LU factorization)."
    },
    {
      "name": "linalg.solve",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.solve",
      "numpy_ref": "np.linalg.solve",
      "category": "counted_custom",
      "cost_formula": "2n^3/3 + n^2*nrhs",
      "cost_formula_latex": "$2n^3/3 + n^2 \\cdot n_{\\text{rhs}}$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Solve Ax=b. Cost: $2n^3/3$ (LU) + $n^2 \\cdot n_{\\text{rhs}}$ (back-substitution)."
    },
    {
      "name": "linalg.svd",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.svd",
      "numpy_ref": "np.linalg.svd",
      "category": "counted_custom",
      "cost_formula": "m * n * k",
      "cost_formula_latex": "$m \\cdot n \\cdot k$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Singular value decomposition; cost ~ O(min(m,n)*m*n)."
    },
    {
      "name": "linalg.svdvals",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.svdvals",
      "numpy_ref": "np.linalg.svdvals",
      "category": "counted_custom",
      "cost_formula": "m * n * min(m,n)",
      "cost_formula_latex": "$m \\cdot n \\cdot \\min(m,n)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Singular values only. Cost: m*n*min(m,n) (Golub-Reinsch)."
    },
    {
      "name": "linalg.tensordot",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.tensordot",
      "numpy_ref": "np.linalg.tensordot",
      "category": "counted_custom",
      "cost_formula": "delegates to me.tensordot",
      "cost_formula_latex": "delegates to `tensordot`",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Delegates to `me.tensordot` which charges FLOPs based on contraction."
    },
    {
      "name": "linalg.tensorinv",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.tensorinv",
      "numpy_ref": "np.linalg.tensorinv",
      "category": "counted_custom",
      "cost_formula": "n^3",
      "cost_formula_latex": "$n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Tensor inverse. Cost: $n^3$ after reshape (delegates to inv)."
    },
    {
      "name": "linalg.tensorsolve",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.tensorsolve",
      "numpy_ref": "np.linalg.tensorsolve",
      "category": "counted_custom",
      "cost_formula": "n^3",
      "cost_formula_latex": "$n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Tensor solve. Cost: $n^3$ after reshape (delegates to solve)."
    },
    {
      "name": "linalg.trace",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.trace",
      "numpy_ref": "np.linalg.trace",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix trace. Cost: n (sum of diagonal elements)."
    },
    {
      "name": "linalg.vecdot",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.vecdot",
      "numpy_ref": "np.linalg.vecdot",
      "category": "counted_custom",
      "cost_formula": "delegates to me.vecdot",
      "cost_formula_latex": "delegates to `vecdot`",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Delegates to `me.vecdot` which charges `2*n` FLOPs."
    },
    {
      "name": "linalg.vector_norm",
      "module": "numpy.linalg",
      "mechestim_ref": "me.linalg.vector_norm",
      "numpy_ref": "np.linalg.vector_norm",
      "category": "counted_custom",
      "cost_formula": "n or 2n",
      "cost_formula_latex": "$n$ or $2n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Vector norm. Cost: numel (or 2*numel for general p-norm)."
    },
    {
      "name": "linspace",
      "module": "numpy",
      "mechestim_ref": "me.linspace",
      "numpy_ref": "np.linspace",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return evenly spaced numbers over interval."
    },
    {
      "name": "load",
      "module": "numpy",
      "mechestim_ref": "me.load",
      "numpy_ref": "np.load",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Load arrays from .npy/.npz files. Not supported."
    },
    {
      "name": "loadtxt",
      "module": "numpy",
      "mechestim_ref": "me.loadtxt",
      "numpy_ref": "np.loadtxt",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Load data from text file. Not supported."
    },
    {
      "name": "log",
      "module": "numpy",
      "mechestim_ref": "me.log",
      "numpy_ref": "np.log",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise natural logarithm."
    },
    {
      "name": "log10",
      "module": "numpy",
      "mechestim_ref": "me.log10",
      "numpy_ref": "np.log10",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise base-10 logarithm."
    },
    {
      "name": "log1p",
      "module": "numpy",
      "mechestim_ref": "me.log1p",
      "numpy_ref": "np.log1p",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise log(1+x) (accurate near zero)."
    },
    {
      "name": "log2",
      "module": "numpy",
      "mechestim_ref": "me.log2",
      "numpy_ref": "np.log2",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise base-2 logarithm."
    },
    {
      "name": "logaddexp",
      "module": "numpy",
      "mechestim_ref": "me.logaddexp",
      "numpy_ref": "np.logaddexp",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "log(exp(x1) + exp(x2)) element-wise."
    },
    {
      "name": "logaddexp2",
      "module": "numpy",
      "mechestim_ref": "me.logaddexp2",
      "numpy_ref": "np.logaddexp2",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "log2(2**x1 + 2**x2) element-wise."
    },
    {
      "name": "logical_and",
      "module": "numpy",
      "mechestim_ref": "me.logical_and",
      "numpy_ref": "np.logical_and",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise logical AND."
    },
    {
      "name": "logical_not",
      "module": "numpy",
      "mechestim_ref": "me.logical_not",
      "numpy_ref": "np.logical_not",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise logical NOT."
    },
    {
      "name": "logical_or",
      "module": "numpy",
      "mechestim_ref": "me.logical_or",
      "numpy_ref": "np.logical_or",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise logical OR."
    },
    {
      "name": "logical_xor",
      "module": "numpy",
      "mechestim_ref": "me.logical_xor",
      "numpy_ref": "np.logical_xor",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise logical XOR."
    },
    {
      "name": "logspace",
      "module": "numpy",
      "mechestim_ref": "me.logspace",
      "numpy_ref": "np.logspace",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Log-spaced generation; cost = num."
    },
    {
      "name": "mask_indices",
      "module": "numpy",
      "mechestim_ref": "me.mask_indices",
      "numpy_ref": "np.mask_indices",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return indices of mask for n x n array."
    },
    {
      "name": "matmul",
      "module": "numpy",
      "mechestim_ref": "me.matmul",
      "numpy_ref": "np.matmul",
      "category": "counted_custom",
      "cost_formula": "2 * m * k * n",
      "cost_formula_latex": "$2 \\cdot m \\cdot k \\cdot n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Matrix multiplication; cost = 2*M*N*K."
    },
    {
      "name": "matrix_transpose",
      "module": "numpy",
      "mechestim_ref": "me.matrix_transpose",
      "numpy_ref": "np.matrix_transpose",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Transpose last two dimensions (NumPy 2.x array API)."
    },
    {
      "name": "max",
      "module": "numpy",
      "mechestim_ref": "me.max",
      "numpy_ref": "np.max",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Maximum value of array."
    },
    {
      "name": "maximum",
      "module": "numpy",
      "mechestim_ref": "me.maximum",
      "numpy_ref": "np.maximum",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise maximum (propagates NaN)."
    },
    {
      "name": "may_share_memory",
      "module": "numpy",
      "mechestim_ref": "me.may_share_memory",
      "numpy_ref": "np.may_share_memory",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Determine if two arrays might share memory."
    },
    {
      "name": "mean",
      "module": "numpy",
      "mechestim_ref": "me.mean",
      "numpy_ref": "np.mean",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Arithmetic mean of array elements."
    },
    {
      "name": "median",
      "module": "numpy",
      "mechestim_ref": "me.median",
      "numpy_ref": "np.median",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Median of array elements (sorts internally)."
    },
    {
      "name": "meshgrid",
      "module": "numpy",
      "mechestim_ref": "me.meshgrid",
      "numpy_ref": "np.meshgrid",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Coordinate matrices from coordinate vectors."
    },
    {
      "name": "min",
      "module": "numpy",
      "mechestim_ref": "me.min",
      "numpy_ref": "np.min",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Minimum value of array."
    },
    {
      "name": "min_scalar_type",
      "module": "numpy",
      "mechestim_ref": "me.min_scalar_type",
      "numpy_ref": "np.min_scalar_type",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return the minimum scalar type for a value."
    },
    {
      "name": "minimum",
      "module": "numpy",
      "mechestim_ref": "me.minimum",
      "numpy_ref": "np.minimum",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise minimum (propagates NaN)."
    },
    {
      "name": "mintypecode",
      "module": "numpy",
      "mechestim_ref": "me.mintypecode",
      "numpy_ref": "np.mintypecode",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return minimum data type character that can satisfy all given types."
    },
    {
      "name": "mod",
      "module": "numpy",
      "mechestim_ref": "me.mod",
      "numpy_ref": "np.mod",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise modulo."
    },
    {
      "name": "modf",
      "module": "numpy",
      "mechestim_ref": "me.modf",
      "numpy_ref": "np.modf",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return fractional and integral parts element-wise."
    },
    {
      "name": "moveaxis",
      "module": "numpy",
      "mechestim_ref": "me.moveaxis",
      "numpy_ref": "np.moveaxis",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Move axes to new positions."
    },
    {
      "name": "multiply",
      "module": "numpy",
      "mechestim_ref": "me.multiply",
      "numpy_ref": "np.multiply",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise multiplication."
    },
    {
      "name": "nan_to_num",
      "module": "numpy",
      "mechestim_ref": "me.nan_to_num",
      "numpy_ref": "np.nan_to_num",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Replace NaN/inf with finite numbers element-wise."
    },
    {
      "name": "nanargmax",
      "module": "numpy",
      "mechestim_ref": "me.nanargmax",
      "numpy_ref": "np.nanargmax",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Index of maximum ignoring NaNs."
    },
    {
      "name": "nanargmin",
      "module": "numpy",
      "mechestim_ref": "me.nanargmin",
      "numpy_ref": "np.nanargmin",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Index of minimum ignoring NaNs."
    },
    {
      "name": "nancumprod",
      "module": "numpy",
      "mechestim_ref": "me.nancumprod",
      "numpy_ref": "np.nancumprod",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative product ignoring NaNs."
    },
    {
      "name": "nancumsum",
      "module": "numpy",
      "mechestim_ref": "me.nancumsum",
      "numpy_ref": "np.nancumsum",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Cumulative sum ignoring NaNs."
    },
    {
      "name": "nanmax",
      "module": "numpy",
      "mechestim_ref": "me.nanmax",
      "numpy_ref": "np.nanmax",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Maximum ignoring NaNs."
    },
    {
      "name": "nanmean",
      "module": "numpy",
      "mechestim_ref": "me.nanmean",
      "numpy_ref": "np.nanmean",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Mean ignoring NaNs."
    },
    {
      "name": "nanmedian",
      "module": "numpy",
      "mechestim_ref": "me.nanmedian",
      "numpy_ref": "np.nanmedian",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Median ignoring NaNs."
    },
    {
      "name": "nanmin",
      "module": "numpy",
      "mechestim_ref": "me.nanmin",
      "numpy_ref": "np.nanmin",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Minimum ignoring NaNs."
    },
    {
      "name": "nanpercentile",
      "module": "numpy",
      "mechestim_ref": "me.nanpercentile",
      "numpy_ref": "np.nanpercentile",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "q-th percentile ignoring NaNs."
    },
    {
      "name": "nanprod",
      "module": "numpy",
      "mechestim_ref": "me.nanprod",
      "numpy_ref": "np.nanprod",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Product ignoring NaNs."
    },
    {
      "name": "nanquantile",
      "module": "numpy",
      "mechestim_ref": "me.nanquantile",
      "numpy_ref": "np.nanquantile",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "q-th quantile ignoring NaNs."
    },
    {
      "name": "nanstd",
      "module": "numpy",
      "mechestim_ref": "me.nanstd",
      "numpy_ref": "np.nanstd",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Standard deviation ignoring NaNs."
    },
    {
      "name": "nansum",
      "module": "numpy",
      "mechestim_ref": "me.nansum",
      "numpy_ref": "np.nansum",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sum ignoring NaNs."
    },
    {
      "name": "nanvar",
      "module": "numpy",
      "mechestim_ref": "me.nanvar",
      "numpy_ref": "np.nanvar",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Variance ignoring NaNs."
    },
    {
      "name": "ndim",
      "module": "numpy",
      "mechestim_ref": "me.ndim",
      "numpy_ref": "np.ndim",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return number of dimensions of array."
    },
    {
      "name": "negative",
      "module": "numpy",
      "mechestim_ref": "me.negative",
      "numpy_ref": "np.negative",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise negation."
    },
    {
      "name": "nested_iters",
      "module": "numpy",
      "mechestim_ref": "me.nested_iters",
      "numpy_ref": "np.nested_iters",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Create nested iterators for multi-index broadcasting. Not supported."
    },
    {
      "name": "nextafter",
      "module": "numpy",
      "mechestim_ref": "me.nextafter",
      "numpy_ref": "np.nextafter",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return next float after x1 toward x2 element-wise."
    },
    {
      "name": "nonzero",
      "module": "numpy",
      "mechestim_ref": "me.nonzero",
      "numpy_ref": "np.nonzero",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return indices of non-zero elements."
    },
    {
      "name": "not_equal",
      "module": "numpy",
      "mechestim_ref": "me.not_equal",
      "numpy_ref": "np.not_equal",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x1 != x2."
    },
    {
      "name": "ones",
      "module": "numpy",
      "mechestim_ref": "me.ones",
      "numpy_ref": "np.ones",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create one-filled array."
    },
    {
      "name": "ones_like",
      "module": "numpy",
      "mechestim_ref": "me.ones_like",
      "numpy_ref": "np.ones_like",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Array of ones with same shape/type as input."
    },
    {
      "name": "outer",
      "module": "numpy",
      "mechestim_ref": "me.outer",
      "numpy_ref": "np.outer",
      "category": "counted_custom",
      "cost_formula": "m * n",
      "cost_formula_latex": "$m \\cdot n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Outer product of two vectors; cost = M*N."
    },
    {
      "name": "packbits",
      "module": "numpy",
      "mechestim_ref": "me.packbits",
      "numpy_ref": "np.packbits",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Pack elements of array into bits."
    },
    {
      "name": "pad",
      "module": "numpy",
      "mechestim_ref": "me.pad",
      "numpy_ref": "np.pad",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Pad array."
    },
    {
      "name": "partition",
      "module": "numpy",
      "mechestim_ref": "me.partition",
      "numpy_ref": "np.partition",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Quickselect; cost = n per slice."
    },
    {
      "name": "percentile",
      "module": "numpy",
      "mechestim_ref": "me.percentile",
      "numpy_ref": "np.percentile",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "q-th percentile of array elements."
    },
    {
      "name": "permute_dims",
      "module": "numpy",
      "mechestim_ref": "me.permute_dims",
      "numpy_ref": "np.permute_dims",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Permute dimensions (NumPy 2.x array API)."
    },
    {
      "name": "piecewise",
      "module": "numpy",
      "mechestim_ref": "me.piecewise",
      "numpy_ref": "np.piecewise",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Evaluate piecewise-defined function. Not supported."
    },
    {
      "name": "place",
      "module": "numpy",
      "mechestim_ref": "me.place",
      "numpy_ref": "np.place",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Change elements satisfying condition."
    },
    {
      "name": "poly",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.poly",
      "numpy_ref": "np.poly",
      "category": "counted_custom",
      "cost_formula": "n^2",
      "cost_formula_latex": "$n^2$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Polynomial from roots. Cost: $n^2$ FLOPs."
    },
    {
      "name": "polyadd",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polyadd",
      "numpy_ref": "np.polyadd",
      "category": "counted_custom",
      "cost_formula": "max(n1, n2)",
      "cost_formula_latex": "$\\max(n_1, n_2)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Add two polynomials. Cost: max(n1, n2) FLOPs."
    },
    {
      "name": "polyder",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polyder",
      "numpy_ref": "np.polyder",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Differentiate polynomial. Cost: n FLOPs."
    },
    {
      "name": "polydiv",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polydiv",
      "numpy_ref": "np.polydiv",
      "category": "counted_custom",
      "cost_formula": "n1 * n2",
      "cost_formula_latex": "$n_1 \\cdot n_2$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Divide one polynomial by another. Cost: n1 * n2 FLOPs."
    },
    {
      "name": "polyfit",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polyfit",
      "numpy_ref": "np.polyfit",
      "category": "counted_custom",
      "cost_formula": "2m * (deg+1)^2",
      "cost_formula_latex": "$2m \\cdot (\\text{deg}+1)^2$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Least squares polynomial fit. Cost: 2 * m * (deg+1)^2 FLOPs."
    },
    {
      "name": "polyint",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polyint",
      "numpy_ref": "np.polyint",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Integrate polynomial. Cost: n FLOPs."
    },
    {
      "name": "polymul",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polymul",
      "numpy_ref": "np.polymul",
      "category": "counted_custom",
      "cost_formula": "n1 * n2",
      "cost_formula_latex": "$n_1 \\cdot n_2$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Multiply polynomials. Cost: n1 * n2 FLOPs."
    },
    {
      "name": "polysub",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polysub",
      "numpy_ref": "np.polysub",
      "category": "counted_custom",
      "cost_formula": "max(n1, n2)",
      "cost_formula_latex": "$\\max(n_1, n_2)$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Difference (subtraction) of two polynomials. Cost: max(n1, n2) FLOPs."
    },
    {
      "name": "polyval",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.polyval",
      "numpy_ref": "np.polyval",
      "category": "counted_custom",
      "cost_formula": "2 * m * deg",
      "cost_formula_latex": "$2 \\cdot m \\cdot \\text{deg}$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Evaluate polynomial at given points. Cost: 2 * m * deg FLOPs (Horner's method)."
    },
    {
      "name": "positive",
      "module": "numpy",
      "mechestim_ref": "me.positive",
      "numpy_ref": "np.positive",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise unary plus (copy with sign preserved)."
    },
    {
      "name": "pow",
      "module": "numpy",
      "mechestim_ref": "me.pow",
      "numpy_ref": "np.pow",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for power (NumPy 2.x)."
    },
    {
      "name": "power",
      "module": "numpy",
      "mechestim_ref": "me.power",
      "numpy_ref": "np.power",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise exponentiation x**y."
    },
    {
      "name": "prod",
      "module": "numpy",
      "mechestim_ref": "me.prod",
      "numpy_ref": "np.prod",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Product of array elements."
    },
    {
      "name": "promote_types",
      "module": "numpy",
      "mechestim_ref": "me.promote_types",
      "numpy_ref": "np.promote_types",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return smallest type to which both types may be safely cast."
    },
    {
      "name": "ptp",
      "module": "numpy",
      "mechestim_ref": "me.ptp",
      "numpy_ref": "np.ptp",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Peak-to-peak (max - min) range of array."
    },
    {
      "name": "put",
      "module": "numpy",
      "mechestim_ref": "me.put",
      "numpy_ref": "np.put",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Replace elements at given flat indices."
    },
    {
      "name": "put_along_axis",
      "module": "numpy",
      "mechestim_ref": "me.put_along_axis",
      "numpy_ref": "np.put_along_axis",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Put values into destination array using indices."
    },
    {
      "name": "putmask",
      "module": "numpy",
      "mechestim_ref": "me.putmask",
      "numpy_ref": "np.putmask",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Change elements of array based on condition and input values."
    },
    {
      "name": "quantile",
      "module": "numpy",
      "mechestim_ref": "me.quantile",
      "numpy_ref": "np.quantile",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "q-th quantile of array elements."
    },
    {
      "name": "rad2deg",
      "module": "numpy",
      "mechestim_ref": "me.rad2deg",
      "numpy_ref": "np.rad2deg",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for degrees."
    },
    {
      "name": "radians",
      "module": "numpy",
      "mechestim_ref": "me.radians",
      "numpy_ref": "np.radians",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Convert degrees to radians element-wise."
    },
    {
      "name": "random.beta",
      "module": "numpy.random",
      "mechestim_ref": "me.random.beta",
      "numpy_ref": "np.random.beta",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.binomial",
      "module": "numpy.random",
      "mechestim_ref": "me.random.binomial",
      "numpy_ref": "np.random.binomial",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.bytes",
      "module": "numpy.random",
      "mechestim_ref": "me.random.bytes",
      "numpy_ref": "np.random.bytes",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.chisquare",
      "module": "numpy.random",
      "mechestim_ref": "me.random.chisquare",
      "numpy_ref": "np.random.chisquare",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.choice",
      "module": "numpy.random",
      "mechestim_ref": "me.random.choice",
      "numpy_ref": "np.random.choice",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output) if replace, n*ceil(log2(n)) if not."
    },
    {
      "name": "random.default_rng",
      "module": "numpy.random",
      "mechestim_ref": "me.random.default_rng",
      "numpy_ref": "np.random.default_rng",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Construct a new Generator with default BitGenerator."
    },
    {
      "name": "random.dirichlet",
      "module": "numpy.random",
      "mechestim_ref": "me.random.dirichlet",
      "numpy_ref": "np.random.dirichlet",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.exponential",
      "module": "numpy.random",
      "mechestim_ref": "me.random.exponential",
      "numpy_ref": "np.random.exponential",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.f",
      "module": "numpy.random",
      "mechestim_ref": "me.random.f",
      "numpy_ref": "np.random.f",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.gamma",
      "module": "numpy.random",
      "mechestim_ref": "me.random.gamma",
      "numpy_ref": "np.random.gamma",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.geometric",
      "module": "numpy.random",
      "mechestim_ref": "me.random.geometric",
      "numpy_ref": "np.random.geometric",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.get_state",
      "module": "numpy.random",
      "mechestim_ref": "me.random.get_state",
      "numpy_ref": "np.random.get_state",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return tuple representing internal state of generator."
    },
    {
      "name": "random.gumbel",
      "module": "numpy.random",
      "mechestim_ref": "me.random.gumbel",
      "numpy_ref": "np.random.gumbel",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.hypergeometric",
      "module": "numpy.random",
      "mechestim_ref": "me.random.hypergeometric",
      "numpy_ref": "np.random.hypergeometric",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.laplace",
      "module": "numpy.random",
      "mechestim_ref": "me.random.laplace",
      "numpy_ref": "np.random.laplace",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.logistic",
      "module": "numpy.random",
      "mechestim_ref": "me.random.logistic",
      "numpy_ref": "np.random.logistic",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.lognormal",
      "module": "numpy.random",
      "mechestim_ref": "me.random.lognormal",
      "numpy_ref": "np.random.lognormal",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.logseries",
      "module": "numpy.random",
      "mechestim_ref": "me.random.logseries",
      "numpy_ref": "np.random.logseries",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.multinomial",
      "module": "numpy.random",
      "mechestim_ref": "me.random.multinomial",
      "numpy_ref": "np.random.multinomial",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.multivariate_normal",
      "module": "numpy.random",
      "mechestim_ref": "me.random.multivariate_normal",
      "numpy_ref": "np.random.multivariate_normal",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.negative_binomial",
      "module": "numpy.random",
      "mechestim_ref": "me.random.negative_binomial",
      "numpy_ref": "np.random.negative_binomial",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.noncentral_chisquare",
      "module": "numpy.random",
      "mechestim_ref": "me.random.noncentral_chisquare",
      "numpy_ref": "np.random.noncentral_chisquare",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.noncentral_f",
      "module": "numpy.random",
      "mechestim_ref": "me.random.noncentral_f",
      "numpy_ref": "np.random.noncentral_f",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.normal",
      "module": "numpy.random",
      "mechestim_ref": "me.random.normal",
      "numpy_ref": "np.random.normal",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.pareto",
      "module": "numpy.random",
      "mechestim_ref": "me.random.pareto",
      "numpy_ref": "np.random.pareto",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.permutation",
      "module": "numpy.random",
      "mechestim_ref": "me.random.permutation",
      "numpy_ref": "np.random.permutation",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Shuffle; cost = n*ceil(log2(n))."
    },
    {
      "name": "random.poisson",
      "module": "numpy.random",
      "mechestim_ref": "me.random.poisson",
      "numpy_ref": "np.random.poisson",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.power",
      "module": "numpy.random",
      "mechestim_ref": "me.random.power",
      "numpy_ref": "np.random.power",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.rand",
      "module": "numpy.random",
      "mechestim_ref": "me.random.rand",
      "numpy_ref": "np.random.rand",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.randint",
      "module": "numpy.random",
      "mechestim_ref": "me.random.randint",
      "numpy_ref": "np.random.randint",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.randn",
      "module": "numpy.random",
      "mechestim_ref": "me.random.randn",
      "numpy_ref": "np.random.randn",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.random",
      "module": "numpy.random",
      "mechestim_ref": "me.random.random",
      "numpy_ref": "np.random.random",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.random_integers",
      "module": "numpy.random",
      "mechestim_ref": "me.random.random_integers",
      "numpy_ref": "np.random.random_integers",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.random_sample",
      "module": "numpy.random",
      "mechestim_ref": "me.random.random_sample",
      "numpy_ref": "np.random.random_sample",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.ranf",
      "module": "numpy.random",
      "mechestim_ref": "me.random.ranf",
      "numpy_ref": "np.random.ranf",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.rayleigh",
      "module": "numpy.random",
      "mechestim_ref": "me.random.rayleigh",
      "numpy_ref": "np.random.rayleigh",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.sample",
      "module": "numpy.random",
      "mechestim_ref": "me.random.sample",
      "numpy_ref": "np.random.sample",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.seed",
      "module": "numpy.random",
      "mechestim_ref": "me.random.seed",
      "numpy_ref": "np.random.seed",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Seed random number generator."
    },
    {
      "name": "random.set_state",
      "module": "numpy.random",
      "mechestim_ref": "me.random.set_state",
      "numpy_ref": "np.random.set_state",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Set internal state of generator."
    },
    {
      "name": "random.shuffle",
      "module": "numpy.random",
      "mechestim_ref": "me.random.shuffle",
      "numpy_ref": "np.random.shuffle",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Shuffle; cost = n*ceil(log2(n))."
    },
    {
      "name": "random.standard_cauchy",
      "module": "numpy.random",
      "mechestim_ref": "me.random.standard_cauchy",
      "numpy_ref": "np.random.standard_cauchy",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.standard_exponential",
      "module": "numpy.random",
      "mechestim_ref": "me.random.standard_exponential",
      "numpy_ref": "np.random.standard_exponential",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.standard_gamma",
      "module": "numpy.random",
      "mechestim_ref": "me.random.standard_gamma",
      "numpy_ref": "np.random.standard_gamma",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.standard_normal",
      "module": "numpy.random",
      "mechestim_ref": "me.random.standard_normal",
      "numpy_ref": "np.random.standard_normal",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.standard_t",
      "module": "numpy.random",
      "mechestim_ref": "me.random.standard_t",
      "numpy_ref": "np.random.standard_t",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.triangular",
      "module": "numpy.random",
      "mechestim_ref": "me.random.triangular",
      "numpy_ref": "np.random.triangular",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.uniform",
      "module": "numpy.random",
      "mechestim_ref": "me.random.uniform",
      "numpy_ref": "np.random.uniform",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.vonmises",
      "module": "numpy.random",
      "mechestim_ref": "me.random.vonmises",
      "numpy_ref": "np.random.vonmises",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.wald",
      "module": "numpy.random",
      "mechestim_ref": "me.random.wald",
      "numpy_ref": "np.random.wald",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.weibull",
      "module": "numpy.random",
      "mechestim_ref": "me.random.weibull",
      "numpy_ref": "np.random.weibull",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "random.zipf",
      "module": "numpy.random",
      "mechestim_ref": "me.random.zipf",
      "numpy_ref": "np.random.zipf",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sampling; cost = numel(output)."
    },
    {
      "name": "ravel",
      "module": "numpy",
      "mechestim_ref": "me.ravel",
      "numpy_ref": "np.ravel",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return contiguous flattened array."
    },
    {
      "name": "ravel_multi_index",
      "module": "numpy",
      "mechestim_ref": "me.ravel_multi_index",
      "numpy_ref": "np.ravel_multi_index",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Convert multi-dimensional index to flat index."
    },
    {
      "name": "real",
      "module": "numpy",
      "mechestim_ref": "me.real",
      "numpy_ref": "np.real",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return real part of complex array."
    },
    {
      "name": "real_if_close",
      "module": "numpy",
      "mechestim_ref": "me.real_if_close",
      "numpy_ref": "np.real_if_close",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return real array if imaginary part is negligible."
    },
    {
      "name": "reciprocal",
      "module": "numpy",
      "mechestim_ref": "me.reciprocal",
      "numpy_ref": "np.reciprocal",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise 1/x."
    },
    {
      "name": "remainder",
      "module": "numpy",
      "mechestim_ref": "me.remainder",
      "numpy_ref": "np.remainder",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise remainder (same as mod)."
    },
    {
      "name": "repeat",
      "module": "numpy",
      "mechestim_ref": "me.repeat",
      "numpy_ref": "np.repeat",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Repeat elements of an array."
    },
    {
      "name": "require",
      "module": "numpy",
      "mechestim_ref": "me.require",
      "numpy_ref": "np.require",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return array that satisfies requirements."
    },
    {
      "name": "reshape",
      "module": "numpy",
      "mechestim_ref": "me.reshape",
      "numpy_ref": "np.reshape",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Reshape array without copying."
    },
    {
      "name": "resize",
      "module": "numpy",
      "mechestim_ref": "me.resize",
      "numpy_ref": "np.resize",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return new array with given shape by repeating."
    },
    {
      "name": "result_type",
      "module": "numpy",
      "mechestim_ref": "me.result_type",
      "numpy_ref": "np.result_type",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return type that results from applying NumPy type promotion."
    },
    {
      "name": "right_shift",
      "module": "numpy",
      "mechestim_ref": "me.right_shift",
      "numpy_ref": "np.right_shift",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise right bit shift (legacy name)."
    },
    {
      "name": "rint",
      "module": "numpy",
      "mechestim_ref": "me.rint",
      "numpy_ref": "np.rint",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Round to nearest integer element-wise."
    },
    {
      "name": "roll",
      "module": "numpy",
      "mechestim_ref": "me.roll",
      "numpy_ref": "np.roll",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Roll array elements along axis."
    },
    {
      "name": "rollaxis",
      "module": "numpy",
      "mechestim_ref": "me.rollaxis",
      "numpy_ref": "np.rollaxis",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Roll specified axis backwards."
    },
    {
      "name": "roots",
      "module": "mechestim._polynomial",
      "mechestim_ref": "me.roots",
      "numpy_ref": "np.roots",
      "category": "counted_custom",
      "cost_formula": "10n^3",
      "cost_formula_latex": "$10n^3$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return roots of polynomial with given coefficients. Cost: $10n^3$ FLOPs (companion matrix eig)."
    },
    {
      "name": "rot90",
      "module": "numpy",
      "mechestim_ref": "me.rot90",
      "numpy_ref": "np.rot90",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Rotate array 90 degrees."
    },
    {
      "name": "round",
      "module": "numpy",
      "mechestim_ref": "me.round",
      "numpy_ref": "np.round",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Round to given number of decimals element-wise."
    },
    {
      "name": "row_stack",
      "module": "numpy",
      "mechestim_ref": "me.row_stack",
      "numpy_ref": "np.row_stack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Stack arrays vertically (alias for vstack)."
    },
    {
      "name": "save",
      "module": "numpy",
      "mechestim_ref": "me.save",
      "numpy_ref": "np.save",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Save array to .npy file. Not supported."
    },
    {
      "name": "savetxt",
      "module": "numpy",
      "mechestim_ref": "me.savetxt",
      "numpy_ref": "np.savetxt",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Save array to text file. Not supported."
    },
    {
      "name": "savez",
      "module": "numpy",
      "mechestim_ref": "me.savez",
      "numpy_ref": "np.savez",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Save multiple arrays to .npz file. Not supported."
    },
    {
      "name": "savez_compressed",
      "module": "numpy",
      "mechestim_ref": "me.savez_compressed",
      "numpy_ref": "np.savez_compressed",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Save multiple arrays to compressed .npz file. Not supported."
    },
    {
      "name": "searchsorted",
      "module": "numpy",
      "mechestim_ref": "me.searchsorted",
      "numpy_ref": "np.searchsorted",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Binary search; cost = m*ceil(log2(n))."
    },
    {
      "name": "select",
      "module": "numpy",
      "mechestim_ref": "me.select",
      "numpy_ref": "np.select",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return array from list of choices based on conditions."
    },
    {
      "name": "setbufsize",
      "module": "numpy",
      "mechestim_ref": "me.setbufsize",
      "numpy_ref": "np.setbufsize",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Set size of buffer used in ufuncs. Not supported."
    },
    {
      "name": "setdiff1d",
      "module": "numpy",
      "mechestim_ref": "me.setdiff1d",
      "numpy_ref": "np.setdiff1d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Set difference; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "seterr",
      "module": "numpy",
      "mechestim_ref": "me.seterr",
      "numpy_ref": "np.seterr",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Set how floating-point errors are handled. Not supported."
    },
    {
      "name": "seterrcall",
      "module": "numpy",
      "mechestim_ref": "me.seterrcall",
      "numpy_ref": "np.seterrcall",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Set callback function for floating-point errors. Not supported."
    },
    {
      "name": "setxor1d",
      "module": "numpy",
      "mechestim_ref": "me.setxor1d",
      "numpy_ref": "np.setxor1d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Symmetric set difference; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "shape",
      "module": "numpy",
      "mechestim_ref": "me.shape",
      "numpy_ref": "np.shape",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return shape of array."
    },
    {
      "name": "shares_memory",
      "module": "numpy",
      "mechestim_ref": "me.shares_memory",
      "numpy_ref": "np.shares_memory",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Determine if two arrays share memory."
    },
    {
      "name": "show_config",
      "module": "numpy",
      "mechestim_ref": "me.show_config",
      "numpy_ref": "np.show_config",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Show NumPy build configuration. Not supported."
    },
    {
      "name": "show_runtime",
      "module": "numpy",
      "mechestim_ref": "me.show_runtime",
      "numpy_ref": "np.show_runtime",
      "category": "blacklisted",
      "cost_formula": "N/A",
      "cost_formula_latex": "N/A",
      "free": false,
      "blocked": true,
      "status": "blocked",
      "notes": "Show runtime info. Not supported."
    },
    {
      "name": "sign",
      "module": "numpy",
      "mechestim_ref": "me.sign",
      "numpy_ref": "np.sign",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise sign function."
    },
    {
      "name": "signbit",
      "module": "numpy",
      "mechestim_ref": "me.signbit",
      "numpy_ref": "np.signbit",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Returns True for elements with negative sign bit."
    },
    {
      "name": "sin",
      "module": "numpy",
      "mechestim_ref": "me.sin",
      "numpy_ref": "np.sin",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise sine."
    },
    {
      "name": "sinc",
      "module": "numpy",
      "mechestim_ref": "me.sinc",
      "numpy_ref": "np.sinc",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Normalized sinc function element-wise."
    },
    {
      "name": "sinh",
      "module": "numpy",
      "mechestim_ref": "me.sinh",
      "numpy_ref": "np.sinh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise hyperbolic sine."
    },
    {
      "name": "size",
      "module": "numpy",
      "mechestim_ref": "me.size",
      "numpy_ref": "np.size",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return number of elements in array."
    },
    {
      "name": "sort",
      "module": "numpy",
      "mechestim_ref": "me.sort",
      "numpy_ref": "np.sort",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Comparison sort; cost = n*ceil(log2(n)) per slice."
    },
    {
      "name": "sort_complex",
      "module": "numpy",
      "mechestim_ref": "me.sort_complex",
      "numpy_ref": "np.sort_complex",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort complex array by real then imaginary part."
    },
    {
      "name": "spacing",
      "module": "numpy",
      "mechestim_ref": "me.spacing",
      "numpy_ref": "np.spacing",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Return ULP spacing for each element."
    },
    {
      "name": "split",
      "module": "numpy",
      "mechestim_ref": "me.split",
      "numpy_ref": "np.split",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Split array into sub-arrays."
    },
    {
      "name": "sqrt",
      "module": "numpy",
      "mechestim_ref": "me.sqrt",
      "numpy_ref": "np.sqrt",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise square root."
    },
    {
      "name": "square",
      "module": "numpy",
      "mechestim_ref": "me.square",
      "numpy_ref": "np.square",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise x^2."
    },
    {
      "name": "squeeze",
      "module": "numpy",
      "mechestim_ref": "me.squeeze",
      "numpy_ref": "np.squeeze",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Remove size-1 dimensions."
    },
    {
      "name": "stack",
      "module": "numpy",
      "mechestim_ref": "me.stack",
      "numpy_ref": "np.stack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Join arrays along new axis."
    },
    {
      "name": "std",
      "module": "numpy",
      "mechestim_ref": "me.std",
      "numpy_ref": "np.std",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Standard deviation; cost_multiplier=2 (two passes)."
    },
    {
      "name": "subtract",
      "module": "numpy",
      "mechestim_ref": "me.subtract",
      "numpy_ref": "np.subtract",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise subtraction."
    },
    {
      "name": "sum",
      "module": "numpy",
      "mechestim_ref": "me.sum",
      "numpy_ref": "np.sum",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sum of array elements."
    },
    {
      "name": "swapaxes",
      "module": "numpy",
      "mechestim_ref": "me.swapaxes",
      "numpy_ref": "np.swapaxes",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Interchange two axes of an array."
    },
    {
      "name": "take",
      "module": "numpy",
      "mechestim_ref": "me.take",
      "numpy_ref": "np.take",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Take elements from array along axis."
    },
    {
      "name": "take_along_axis",
      "module": "numpy",
      "mechestim_ref": "me.take_along_axis",
      "numpy_ref": "np.take_along_axis",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Take values from input array by matching 1-D index."
    },
    {
      "name": "tan",
      "module": "numpy",
      "mechestim_ref": "me.tan",
      "numpy_ref": "np.tan",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise tangent."
    },
    {
      "name": "tanh",
      "module": "numpy",
      "mechestim_ref": "me.tanh",
      "numpy_ref": "np.tanh",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise hyperbolic tangent."
    },
    {
      "name": "tensordot",
      "module": "numpy",
      "mechestim_ref": "me.tensordot",
      "numpy_ref": "np.tensordot",
      "category": "counted_custom",
      "cost_formula": "product of contracted dims * output size",
      "cost_formula_latex": "$\\prod_i d_i$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Tensor dot product along specified axes."
    },
    {
      "name": "tile",
      "module": "numpy",
      "mechestim_ref": "me.tile",
      "numpy_ref": "np.tile",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Repeat array by tiling."
    },
    {
      "name": "trace",
      "module": "numpy",
      "mechestim_ref": "me.trace",
      "numpy_ref": "np.trace",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Diagonal sum; cost = min(n,m)."
    },
    {
      "name": "transpose",
      "module": "numpy",
      "mechestim_ref": "me.transpose",
      "numpy_ref": "np.transpose",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Permute array dimensions."
    },
    {
      "name": "trapezoid",
      "module": "numpy",
      "mechestim_ref": "me.trapezoid",
      "numpy_ref": "np.trapezoid",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Integrate using the trapezoidal rule."
    },
    {
      "name": "trapz",
      "module": "numpy",
      "mechestim_ref": "me.trapz",
      "numpy_ref": "np.trapz",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Alias for trapezoid (deprecated)."
    },
    {
      "name": "tri",
      "module": "numpy",
      "mechestim_ref": "me.tri",
      "numpy_ref": "np.tri",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Array with ones at and below given diagonal."
    },
    {
      "name": "tril",
      "module": "numpy",
      "mechestim_ref": "me.tril",
      "numpy_ref": "np.tril",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Lower triangle of array."
    },
    {
      "name": "tril_indices",
      "module": "numpy",
      "mechestim_ref": "me.tril_indices",
      "numpy_ref": "np.tril_indices",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return lower-triangle indices for n x n array."
    },
    {
      "name": "tril_indices_from",
      "module": "numpy",
      "mechestim_ref": "me.tril_indices_from",
      "numpy_ref": "np.tril_indices_from",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return lower-triangle indices for given array."
    },
    {
      "name": "trim_zeros",
      "module": "numpy",
      "mechestim_ref": "me.trim_zeros",
      "numpy_ref": "np.trim_zeros",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Trim leading/trailing zeros from 1-D array."
    },
    {
      "name": "triu",
      "module": "numpy",
      "mechestim_ref": "me.triu",
      "numpy_ref": "np.triu",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Upper triangle of array."
    },
    {
      "name": "triu_indices",
      "module": "numpy",
      "mechestim_ref": "me.triu_indices",
      "numpy_ref": "np.triu_indices",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return upper-triangle indices for n x n array."
    },
    {
      "name": "triu_indices_from",
      "module": "numpy",
      "mechestim_ref": "me.triu_indices_from",
      "numpy_ref": "np.triu_indices_from",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return upper-triangle indices for given array."
    },
    {
      "name": "true_divide",
      "module": "numpy",
      "mechestim_ref": "me.true_divide",
      "numpy_ref": "np.true_divide",
      "category": "counted_binary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Element-wise true division (explicit)."
    },
    {
      "name": "trunc",
      "module": "numpy",
      "mechestim_ref": "me.trunc",
      "numpy_ref": "np.trunc",
      "category": "counted_unary",
      "cost_formula": "numel(output)",
      "cost_formula_latex": "$\\text{numel}(\\text{output})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Truncate toward zero element-wise."
    },
    {
      "name": "typename",
      "module": "numpy",
      "mechestim_ref": "me.typename",
      "numpy_ref": "np.typename",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Return description of given data type code."
    },
    {
      "name": "union1d",
      "module": "numpy",
      "mechestim_ref": "me.union1d",
      "numpy_ref": "np.union1d",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Set union; cost = (n+m)*ceil(log2(n+m))."
    },
    {
      "name": "unique",
      "module": "numpy",
      "mechestim_ref": "me.unique",
      "numpy_ref": "np.unique",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort-based unique; cost = n*ceil(log2(n))."
    },
    {
      "name": "unique_all",
      "module": "numpy",
      "mechestim_ref": "me.unique_all",
      "numpy_ref": "np.unique_all",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort-based unique; cost = n*ceil(log2(n))."
    },
    {
      "name": "unique_counts",
      "module": "numpy",
      "mechestim_ref": "me.unique_counts",
      "numpy_ref": "np.unique_counts",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort-based unique; cost = n*ceil(log2(n))."
    },
    {
      "name": "unique_inverse",
      "module": "numpy",
      "mechestim_ref": "me.unique_inverse",
      "numpy_ref": "np.unique_inverse",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort-based unique; cost = n*ceil(log2(n))."
    },
    {
      "name": "unique_values",
      "module": "numpy",
      "mechestim_ref": "me.unique_values",
      "numpy_ref": "np.unique_values",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Sort-based unique; cost = n*ceil(log2(n))."
    },
    {
      "name": "unpackbits",
      "module": "numpy",
      "mechestim_ref": "me.unpackbits",
      "numpy_ref": "np.unpackbits",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Unpack elements of array into bits."
    },
    {
      "name": "unravel_index",
      "module": "numpy",
      "mechestim_ref": "me.unravel_index",
      "numpy_ref": "np.unravel_index",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Convert flat index to multi-dimensional index."
    },
    {
      "name": "unstack",
      "module": "numpy",
      "mechestim_ref": "me.unstack",
      "numpy_ref": "np.unstack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Unstack array along axis into tuple of arrays (NumPy 2.x)."
    },
    {
      "name": "unwrap",
      "module": "mechestim._unwrap",
      "mechestim_ref": "me.unwrap",
      "numpy_ref": "np.unwrap",
      "category": "counted_custom",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Phase unwrap. Cost: $\\text{numel}(\\text{input})$ (diff + conditional adjustment)."
    },
    {
      "name": "vander",
      "module": "numpy",
      "mechestim_ref": "me.vander",
      "numpy_ref": "np.vander",
      "category": "counted_custom",
      "cost_formula": "per-operation",
      "cost_formula_latex": "varies",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Vandermonde matrix; cost = len(x)*(N-1)."
    },
    {
      "name": "var",
      "module": "numpy",
      "mechestim_ref": "me.var",
      "numpy_ref": "np.var",
      "category": "counted_reduction",
      "cost_formula": "numel(input)",
      "cost_formula_latex": "$\\text{numel}(\\text{input})$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Variance; cost_multiplier=2 (two passes)."
    },
    {
      "name": "vdot",
      "module": "numpy",
      "mechestim_ref": "me.vdot",
      "numpy_ref": "np.vdot",
      "category": "counted_custom",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Dot product with conjugation; cost = 2*N."
    },
    {
      "name": "vecdot",
      "module": "numpy",
      "mechestim_ref": "me.vecdot",
      "numpy_ref": "np.vecdot",
      "category": "counted_binary",
      "cost_formula": "n",
      "cost_formula_latex": "$n$",
      "free": false,
      "blocked": false,
      "status": "supported",
      "notes": "Vector dot product along last axis."
    },
    {
      "name": "vsplit",
      "module": "numpy",
      "mechestim_ref": "me.vsplit",
      "numpy_ref": "np.vsplit",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Split array into rows."
    },
    {
      "name": "vstack",
      "module": "numpy",
      "mechestim_ref": "me.vstack",
      "numpy_ref": "np.vstack",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Stack arrays vertically."
    },
    {
      "name": "where",
      "module": "numpy",
      "mechestim_ref": "me.where",
      "numpy_ref": "np.where",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Select elements based on condition."
    },
    {
      "name": "zeros",
      "module": "numpy",
      "mechestim_ref": "me.zeros",
      "numpy_ref": "np.zeros",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Create zero-filled array."
    },
    {
      "name": "zeros_like",
      "module": "numpy",
      "mechestim_ref": "me.zeros_like",
      "numpy_ref": "np.zeros_like",
      "category": "free",
      "cost_formula": "0",
      "cost_formula_latex": "$0$",
      "free": true,
      "blocked": false,
      "status": "supported",
      "notes": "Array of zeros with same shape/type as input."
    }
  ],
  "total": 482
}