Computational operators
74 operators in the computational category of the live registry. Compose them in a contract or call POST /api/zeq/compute — KO42 is always on, plus up to three more per call.
How it computes: dedicated closed-form solver solveCS — real equations over CODATA-2018 constants; where an operator needs a series/matrix/field a scalar cannot express, it refuses honestly. See the solvers.
| Operator | Description | Equation |
|---|---|---|
AEO1 | Electrostatic energy density integral E1 = integral of (1/2)epsilon_0E^2 over volume, computing stored electric field energy. | \frac{\partial \vec{v}}{\partial t} + (\vec{v} \cdot \nabla)\vec{v} = -\frac{1}{\rho}\nabla p + \nu\nabla^2\vec{v} + \vec{g} + 2\vec{\Omega} \times \vec{v} + \vec{F}_{coriolis} |
AEO15 | Electric flux surface integral A15 = integral of E dot dA, extended surface integral for arbitrary geometries. | \frac{\partial T}{\partial t} = -u \frac{\partial T}{\partial x} - w \frac{\partial T}{\partial z} + Q_{net} - \alpha(T - T_0) + \eta_{stochastic} |
AEO3 | Poynting flux integral E3 = (1/mu_0)*integral of (E cross B) dot dA, computing electromagnetic energy flow through a surface. | \frac{dq}{dt} = E - P + \nabla \cdot (K\nabla q) - \vec{v} \cdot \nabla q + S_{phase} |
AEO7 | Electric flux integral A7 = integral of E dot dA, computing the electric field flux through a closed surface. | \frac{d}{dt}(\zeta + f) = -(\zeta + f)\nabla \cdot \vec{v} + \frac{1}{\rho^2}\nabla \rho \times \nabla p \cdot \hat{k} + \vec{k} \cdot \nabla \times \vec{F} |
AJ5 | Axial current density J5 = psi-bar * gamma_5 * psi, measuring chiral asymmetry in fermionic fields. | J_5 = \bar{\psi}\gamma_5\psi |
CA0 | Computational expectation value operator C = integral of Psi* times observable operator C-hat times Psi over configuration space. | K(y|x*) - K(y) |
CS43 | Linearithmic time complexity O(n log n) — e.g. comparison sorting and the FFT. | O(n log n) |
CS44 | Linear space complexity O(n). | T(n) = O(n) |
CS45 | Logarithmic quantum query complexity O(log n). | T(n) = O(\log n), \text{ binary search} |
CS46 | Amdahl's law bounding parallel speed-up by the serial fraction of a workload. | 1/((1-f) + f/n) |
CS47 | Shannon entropy of a probability distribution, H = −∑ p log p. | -∑p(x)log p(x) |
CS48 | Cubic time complexity O(n cubed), arising in naive matrix multiplication and three-nested-loop algorithms. | T(n) = O(1) |
CS49 | Exponential time complexity O(2^n), characteristic of brute-force search over all subsets. | 1 - e⁻λ |
CS50 | Factorial time complexity O(n!), arising in brute-force permutation enumeration such as naive TSP. | T(n) = O(\log_2 n), \text{ balanced BST lookup} |
CS51 | Fast Fourier Transform computing the DFT in O(n log n) via recursive divide-and-conquer decomposition. | hits/(hits + misses) |
CS52 | Discrete Fourier Transform decomposing a finite signal into its constituent frequency components. | block time/network propagation |
CS53 | Shannon entropy H(X) = -sum of p(x_i) log2 p(x_i), measuring the average information content of a source. | transactions/time slot |
CS54 | Mutual information I(X;Y) quantifying the shared information between two random variables via joint and marginal entropies. | -η ∂L/∂w |
CS55 | Universal hash function h(x) = ((ax+b) mod p) mod m guaranteeing low collision probability for any input distribution. | ∑γᵗ r_t |
CS56 | Bloom filter false-positive probability P_fp = (1 - e^(-kn/m))^k for space-efficient probabilistic set membership. | \hat{y} = \sigma(\mathbf{A} \cdot \mathbf{X} \cdot \mathbf{W}) |
CS57 | Binary search tree height bound h = floor(log2 n) + 1 for a balanced BST with n nodes. | T = O(n_{\text{qubits}} \times n_{\text{gates}}) |
CS58 | Binary heap parent index relation parent(i) = floor(i/2) enabling implicit array-based tree storage. | -Tr(ρ log ρ) |
CS59 | Maximum edge count in an undirected simple graph: E <= V(V-1)/2 bounding the complete graph density. | F = |\langle\psi_1|\psi_2\rangle|^2 |
CS60 | Dijkstra's shortest-path relaxation d[v] = min(d[v], d[u]+w(u,v)) for non-negative edge weights. | energy/transaction |
CS61 | A* search evaluation function f(n) = g(n)+h(n) combining path cost with admissible heuristic estimate. | N = 2^n |
CS62 | Quicksort average-case recurrence T(n) = 2T(n/2)+O(n) via in-place partitioning around a pivot. | log(1/ε) |
CS63 | Mergesort recurrence T(n) = 2T(n/2)+O(n), a stable divide-and-conquer sort guaranteed O(n log n). | O(|w| + |x|) |
CS64 | Dynamic programming optimal substructure dp[i] storing solutions to overlapping subproblems for bottom-up computation. | (Threat × Vulnerability)/Countermeasures |
CS65 | Greedy algorithm paradigm making locally optimal choices at each step to construct a globally optimal solution. | -∑p_i log₂ p_i |
CS66 | Breadth-first search computing shortest unweighted distances d[v] = d[u]+1 by level-order traversal. | Packets Lost/Packets Sent |
CS67 | Depth-first search recording discovery and finish times for topological sorting and cycle detection. | O(log V) |
CS68 | Minimum spanning tree minimizing total edge weight w(T) = sum of w(u,v) connecting all vertices. | MSS/RTT × 1/√p |
CS69 | Bellman-Ford algorithm finding shortest paths with negative edge weights via iterative relaxation. | D/V |
CS70 | Floyd-Warshall all-pairs shortest path algorithm using dynamic programming on intermediate vertices. | B log₂(1 + SNR) |
CS71 | Backtracking search with worst-case O(b^d) exploring the solution space by systematic trial and rollback. | T(n) = O(\log n), \text{ heap extract-min} |
CS72 | Branch and bound optimization pruning the search tree using lower bounds to discard suboptimal branches. | O(log_m n) |
CS73 | Divide and conquer recurrence T(n) = aT(n/b)+f(n) solved by the master theorem for asymptotic complexity. | |{Relevant} ∩ {Retrieved}| / |{Retrieved}| |
CS74 | Newton's root-finding method x_{n+1} = x_n - f(x_n)/f'(x_n) with quadratic convergence near simple roots. | |{Relevant} ∩ {Retrieved}| / |{Relevant}| |
CS75 | Gradient descent iteratively moving x_{n+1} = x_n - alpha*grad(f) downhill to minimize a differentiable function. | 1 - Hits/Accesses |
CS76 | Convex function condition ensuring any local minimum is a global minimum, enabling efficient optimization. | log₂(2D/W) |
CS77 | Linear programming: maximize c'x subject to Ax <= b, optimizing a linear objective over a polyhedral feasible region. | a + b log₂(n) |
CS78 | Simplex method traversing vertices of the feasible polytope to find the optimal linear programming solution. | ∑₁¹⁰ w_i h_i |
CS79 | Integer programming restricting decision variables to integers, rendering linear programs NP-hard in general. | (Intrinsic + Extraneous)/Germane |
CS80 | Boolean satisfiability (SAT) problem: determine if a propositional formula has a satisfying truth assignment. | λx.e → e[x := a] |
CS81 | 3-SAT, the canonical NP-complete problem, restricting SAT clauses to exactly three literals each. | x̅⟨y⟩.P | x(z).Q → P | Q[z:=y] |
CS82 | Subset sum problem: decide whether a subset of integers sums to a given target, a classic NP-complete problem. | E - N + 2P |
CS83 | Traveling salesman problem: find the minimum-cost Hamiltonian cycle through all cities, NP-hard to optimize. | η₁ log₂ η₁ + η₂ log₂ η₂ |
CS84 | Formal definition of an asymptotic upper bound (Big-O). | f(n) = O(g(n)) |
CS85 | Levenshtein edit distance computing the minimum insertions, deletions, and substitutions to transform one string into another. | Effectively Calculable = Turing Computable |
CS86 | Longest common subsequence (LCS) finding the longest subsequence shared by two sequences via dynamic programming. | P = NP? |
CS87 | Kolmogorov complexity: the length of the shortest program that outputs x. | Ω(x) = min{|p| : U(p) = x} |
CS88 | Context-free grammar generating languages parseable by pushdown automata, foundation of compiler design. | Regular ⊂ Context-Free ⊂ Context-Sensitive ⊂ Recursively Enumerable |
CS89 | Turing machine transition function delta defining state changes, tape writes, and head movement for universal computation. | Transistors ∝ 2^(t/2) |
CS90 | NP verification: a decision problem is in NP if a proposed solution can be verified in polynomial time. | 1/((1-p) + p/s) |
CS91 | P vs NP problem asking whether every problem with polynomial-time verification also has polynomial-time solution. | s + p(1-s) |
CS92 | Polynomial-time reduction transforming one decision problem into another, preserving computational tractability. | min(π·I, β) |
FC_GS | Unified wavefunction superposition psi_unified = sum of w_i * Psi_i, combining multiple quantum states with weighting coefficients. | \psi_{unified}^{(605)} = \sum_i w_i \Psi_i |
FC_QA | Charge flux operator Q_A = integral of J dot dA, computing total current flowing through a cross-sectional area. | Q_A = \int_{\partial A} \vec{J} \cdot d\vec{A} |
FC_SC | Entropy in Boltzmann units beta_607 = S/k_B, expressing thermodynamic entropy as a dimensionless quantity. | \beta_{607} = \frac{S}{k_B} |
ICO8 | Information cosmology integration operator I_int = Phi * e^(iomegat), computational variant of information-cosmology field integration. | \frac{d\vec{x}}{dt} = \vec{F}(\vec{x}), \quad \lambda_i = \lim_{t\to\infty} \frac{1}{t} \ln \left| \frac{\partial \vec{x}(t)}{\partial \vec{x}(0)} \right| |
IF0 | Euler-Lagrange functional I[f] = integral of L(x,f,f')dx, the variational principle for finding extremal paths. | \mathcal{I}(\theta) = \int \left(\frac{\partial \log f(x;\theta)}{\partial \theta}\right)^2 f(x;\theta) \, dx |
MC0 | Monte Carlo ensemble average | \langle O \rangle = \frac{1}{Z}\int O e^{-\beta H} d\Gamma |
NCR0 | Stirling's approximation N! ~ sqrt(2piN)*(N/e)^N for efficient computation of large factorials. | C_m dV/dt = -∑I_ion + I_app |
PC0 | Classical probability P_C = |A|/|Omega|, the ratio of favorable outcomes to total sample space cardinality. | ħ/(2mi)(ψ∇ψ - ψ∇ψ) |
ST1 | Arithmetic mean mu = (1/N) sum of x_i, the first moment estimating the central tendency of a dataset. | \bar{x} = \frac{1}{n}\sum_{i=1}^n x_i |
ST10 | Coefficient of determination R-squared measuring the proportion of variance in a dependent variable explained by the regression model. | R^2 = 1 - \frac{SS_{res}}{SS_{tot}} |
ST2 | Standard deviation sigma = sqrt((1/N) sum of (x_i - mu)^2), measuring the dispersion of data around the mean. | \sigma = \sqrt{\frac{1}{n}\sum_{i=1}^n (x_i - \bar{x})^2} |
ST3 | Bayes' theorem P(A|B) = P(B|A)*P(A)/P(B), updating prior beliefs with observed evidence to obtain posterior probability. | P(A|B) = \frac{P(B|A)P(A)}{P(B)} |
ST4 | Binomial distribution P(k) = C(n,k)p^k(1-p)^(n-k) giving the probability of k successes in n independent trials. | P(X=k) = \binom{n}{k}p^k(1-p)^{n-k} |
ST5 | Normal distribution f(x) = (1/(sigmasqrt(2pi)))e^(-(x-mu)^2/(2sigma^2)), the bell curve of natural variation. | f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{(x-\mu)^2}{2\sigma^2}} |
ST6 | Pearson correlation coefficient r = Cov(X,Y)/(sigma_X*sigma_Y) measuring linear association between two variables. | \rho = \frac{\sum(x_i-\bar{x})(y_i-\bar{y})}{\sqrt{\sum(x_i-\bar{x})^2\sum(y_i-\bar{y})^2}} |
ST7 | Chi-squared test statistic chi^2 = sum of (O_i - E_i)^2/E_i for goodness-of-fit and independence testing. | \chi^2 = \sum\frac{(O_i - E_i)^2}{E_i} |
ST8 | Student's t-test statistic t = (x_bar - mu)/(s/sqrt(n)) for hypothesis testing with small sample sizes. | t = \frac{\bar{x} - \mu}{s/\sqrt{n}} |
ST9 | F-test statistic F = s1^2/s2^2 comparing two sample variances, central to analysis of variance (ANOVA). | F = \frac{s_1^2}{s_2^2} |
Compute one — a real call
curl -sS -X POST https://zeqsdk.com/api/zeq/compute \
-H "Authorization: Bearer $ZEQ_KEY" \
-H "Content-Type: application/json" \
-d '{"operators":["CS46"],"inputs":{"f":0.9,"n":10}}'
Returns 5.2632 speedup — with unit, uncertainty, the generated master equation, and a signed envelope you can verify.
See also
- The solvers — the coverage map and the ODE fallback
- The honesty contract — compute, ask, or refuse
- All operator categories