MoCQ: Multi-Domain Approaches

• MoCQ is a term with multiple domain-specific interpretations, referring to a multi-branched moment method for exact queueing network analysis and a neuro-symbolic framework for static vulnerability detection.
• In queueing theory, MoCQ extends the Method of Moments with generalized convolution expressions and multi-branched recursions to achieve significant gains in speed and memory efficiency.
• In static vulnerability detection, MoCQ integrates LLM-driven query synthesis with classical static analysis, achieving competitive recall and precision compared to expert-crafted methods.

MoCQ is not a single standardized term in the arXiv literature. It denotes at least two unrelated research constructs, and in one technical summary it is also used as a label for a Mix-of-Experts quantization scheme whose paper title uses MoQa rather than MoCQ. In queueing theory, MoCQ refers to a multi-branched generalization of the Method of Moments for exact analysis of closed multiclass product-form queueing networks (0902.3065). In software security, MoCQ denotes a neuro-symbolic framework for automated static vulnerability detection that combines LLM-generated query synthesis with classical static-analysis feedback (Li et al., 22 Apr 2025). The term therefore has to be interpreted from disciplinary context rather than from the acronym alone.

1. Scope and nomenclature

The literature represented here uses MoCQ in multiple domain-specific ways.

Usage of “MoCQ”	Domain	Source
Multi-branched Method of Moments	Queueing networks	(0902.3065)
“Model-Generated Code Queries”	Static vulnerability detection	(Li et al., 22 Apr 2025)
Label used in a technical summary for a framework titled MoQa	MoE quantization	(Zheng et al., 27 Mar 2025)

This multiplicity matters because several nearby acronyms are visually similar but methodologically unrelated. MoQuad is a motion-focused quadruple construction strategy for video contrastive learning (Liu et al., 2022). MOCC is multi-objective congestion control (Ma et al., 2021). MQMC is multi-queue momentum contrast for microvideo-product retrieval (Du et al., 2022). CmOS addresses visual option generation for MCQs (Wang et al., 26 Aug 2025). A common misconception is to treat these labels as a shared family; the cited works do not support that interpretation.

2. MoCQ in queueing-network analysis

In queueing theory, MoCQ is an exact solution algorithm for closed multiclass product-form queueing networks with $M$ distinct service centers, $R$ customer classes, a population vector $\mathbf{N}=(N_1,\dots,N_R)$, service demands $D_{k,r}>0$, think times $Z_r\ge 0$, and a multiplicity vector $\mathbf{m}=(m_1,\dots,m_M)$ whose entries count identical copies of each queue type (0902.3065). The equilibrium distribution is normalized by the constant $G(\mathbf{m},\mathbf{N})$, and standard performance indices are recovered from normalization-constant identities: $$X_r(\mathbf{N})=\frac{G(\mathbf{m},\mathbf{N}-\mathbf{1}_r)}{G(\mathbf{m},\mathbf{N})}, \qquad Q_{k,r}(\mathbf{N})=\frac{D_{k,r}\,G(\mathbf{m}+\mathbf{1}_k,\mathbf{N}-\mathbf{1}_r)}{G(\mathbf{m},\mathbf{N})}.$$

The starting point is the baseline Method of Moments (MoM), which recursively computes higher-order moments of queue lengths rather than mean values. MoM aggregates the classical Convolution Expression (CE) and Population Constraint (PC) recurrences into a linear matrix-difference system over a basis vector $\mathbf{V}(\mathbf{N})$ consisting of normalization constants for augmented networks. Given the boundary condition $G(\mathbf{m},\mathbf{0})=1$, the recursion advances forward in population until $R$0 is obtained (0902.3065).

The central innovation of the multi-branched variant is to enlarge the information set available to the recursion by adding the Generalized Convolution Expression (GCE),

$R$1

whenever $R$2 is nonnegative. This couples the target model to smaller-queue submodels and turns the computation into a multi-branched recursion over reduced queue configurations (0902.3065).

3. Multi-branched recursion, matrix formulation, and complexity

The final formulation introduces a reduced basis $R$3 with level $R$4, where $R$5 is the number of injected GCE branches. The resulting matrix-difference equation is

$R$6

where $R$7 is the basis for the submodel with multiplicity $R$8 and $R$9 is a 0–1 selection matrix injecting the corresponding GCE contribution (0902.3065). Under mild combinatorial conditions, $\mathbf{N}=(N_1,\dots,N_R)$0 has full column rank, so the system may be solved by QR factorization or block Wiedemann methods.

Algorithmically, MoCQ recursively computes queue-reduced bases, assembles $\mathbf{N}=(N_1,\dots,N_R)$1, $\mathbf{N}=(N_1,\dots,N_R)$2, and the GCE right-hand side, solves the resulting over-determined or square linear system, and returns the basis values required for the target model (0902.3065). The method is exact rather than simulation-based.

Its cost profile is driven by the reduced basis size

$\mathbf{N}=(N_1,\dots,N_R)$3

with per-step linear-system solution cost

$\mathbf{N}=(N_1,\dots,N_R)$4

where $\mathbf{N}=(N_1,\dots,N_R)$5 is the overhead of exact integer or arbitrary-precision arithmetic (0902.3065). The paper contrasts this with Mean Value Analysis, which is $\mathbf{N}=(N_1,\dots,N_R)$6 in time and space, and with the original MoM, whose system dimension grows as $\mathbf{N}=(N_1,\dots,N_R)$7. Multi-branched MoCQ preserves the $\mathbf{N}=(N_1,\dots,N_R)$8 scaling of MoM while replacing the system dimension by the reduced $\mathbf{N}=(N_1,\dots,N_R)$9; computational analysis reports several cases where it is between $D_{k,r}>0$0 and $D_{k,r}>0$1 times faster and less memory consuming than original MoM (0902.3065).

Implementation remarks are integral to the method rather than ancillary. The linear solves can be carried out with exact algorithms such as Wiedemann’s method or modular Gaussian elimination, avoiding catastrophic round-off in deep product-form recursions. The use of GCEs also reduces the largest integer sizes encountered. In the $D_{k,r}>0$2 case, the recursion is described as embarrassingly parallel over combinatorial submodels, which suggests natural divide-and-conquer and task-parallel implementations (0902.3065).

4. MoCQ as a neuro-symbolic framework for static vulnerability detection

In software security, MoCQ is a holistic neuro-symbolic framework for automated static vulnerability detection that combines LLMs with classical static analysis (Li et al., 22 Apr 2025). The motivation is explicit: static vulnerability detection still requires excessive human effort for vulnerability-pattern engineering, while pure LLM approaches suffer from hallucinations, poor recall and precision, and weak scalability. MoCQ addresses this by using an LLM to extract vulnerability patterns and translate them into executable queries, then using a static-analysis engine to refine those queries in a feedback loop (Li et al., 22 Apr 2025).

The architecture has four major components. First, DSL Extraction & Subsetting crawls tool documentation and implementation to recover the full DSL grammar and API semantics, then selects a minimal core subset. Second, the LLM-Based Pattern Extractor consumes a vulnerability description, several vulnerable code examples, and the core DSL subset, and emits pattern templates plus per-example query drafts. Third, the Symbolic Query Translator & Validator converts those templates into executable DSL queries and executes them on example code while instrumenting syntax and semantic failure points. Fourth, the Static-Analysis Refinement Engine analyzes syntax errors, runtime exceptions, missing matches, and over- or under-fitting, and feeds precise debugging information back to the LLM for regeneration (Li et al., 22 Apr 2025).

Internally, the generated patterns are represented as small AST-pattern objects containing node types, predicates on identifiers or operators, and data-flow edges. The framework formalizes a vulnerability pattern as a predicate

$D_{k,r}>0$3

implemented by a DSL query through traversal and filtering (Li et al., 22 Apr 2025). This formalization situates MoCQ within the static-analysis paradigm used by systems such as Joern, Semgrep, and CodeQL.

The refinement mechanism is central. Syntax failures identify violated grammar rules; runtime failures detect API misuse or parameter-type errors; semantic failures locate the first execution block after which matches drop to zero and return the captured program state for debugging; over- and under-fitting are handled by asking the LLM to generalize overly specific constants or add constraints for overly broad queries (Li et al., 22 Apr 2025). After per-example queries stabilize, MoCQ performs an LLM-assisted query-merging step to obtain a single query per vulnerability type.

5. Evaluation of vulnerability-detection MoCQ

The reported evaluation covers seven OWASP Top Ten classes across two programming languages: SQL injection, cross-site scripting, type juggling, and deserialization in PHP; prototype pollution, command injection, and XSS in JavaScript (Li et al., 22 Apr 2025). The generation set contains 15 projects with 192 known vulnerabilities; the testing set contains 5 held-out projects with 73 vulnerabilities; and a latest-version set contains 19 real-world projects without prior ground truth for zero-day search (Li et al., 22 Apr 2025).

On the testing set, the summary reports 72 total true positives. MoCQ attains 56 TP and 90 FP, corresponding to Recall 0.77 and Precision 0.38. Expert-crafted queries attain 50 TP and 92 FP, corresponding to Recall 0.69 and Precision 0.35. The combined system, MoCQ + Experts, reaches Recall 0.87 and Precision 0.37 (Li et al., 22 Apr 2025). The abstract characterizes this as comparable precision and recall relative to expert-crafted queries.

The framework also uncovers at least 12 patterns missed by experts, including atomic DSL operations or data-flow idioms such as PHP’s array_flip and JavaScript’s Reflect.set, and identifies seven previously unknown vulnerabilities in real-world applications; these were responsibly disclosed to developers (Li et al., 22 Apr 2025). A representative case study involves JavaScript prototype pollution in es2015-proxy: the LLM first extracts a pattern involving user input, JSON.parse, and Object.assign on __proto__; the translator emits a Joern query; the validator observes zero matches; symbolic feedback reveals that the parse chain is missing; and a corrected query then matches the proof of concept and generalizes to variants such as Reflect.set (Li et al., 22 Apr 2025).

The limitations are also explicit. MoCQ depends on having at least a handful of ground-truth vulnerability examples; LLM non-determinism and inference cost can increase the number of refinement iterations; and missed matches can arise when static-analysis frontends incompletely model dynamic language features such as JavaScript reflection (Li et al., 22 Apr 2025). This suggests that MoCQ’s performance ceiling is partly constrained by the expressivity and semantic fidelity of the underlying analyzer.

6. Terminological collisions and adjacent usages

A further terminological complication arises in the MoE quantization literature. The paper “MoQa: Rethinking MoE Quantization with Multi-stage Data-model Distribution Awareness” presents a framework named MoQa, but its accompanying technical summary begins with the label “Technical Overview of MoCQ: Mix-of-Experts Quantization via Multi-Stage Data-Model Distribution Awareness” (Zheng et al., 27 Mar 2025). The framework itself performs a three-stage analysis of token-level distribution and re-weighting, data-model mapping through routed experts, and inter-expert correlation; it then combines expert-level mix-precision base quantization with channel-level dynamic quantization adjustment (Zheng et al., 27 Mar 2025). The reported outcomes include 0.49–8.51 PPL decrease on known distributions, 2.74–6.44 PPL decrease on novel distributions, and 1.85%–3.77% average accuracy improvements on novel distributions (Zheng et al., 27 Mar 2025). In context, however, the stable title-level name is MoQa, not MoCQ.

Several nearby acronyms should likewise be separated from MoCQ. MoQuad retains a SimCLR-style framework while constructing anchor, appearance-disturbed positive, and two intra-video negatives to enforce motion discrimination in video contrastive learning (Liu et al., 2022). MOCC formulates congestion control as a multi-objective MDP and learns preference-conditioned policies through actor-critic RL and transfer learning (Ma et al., 2021). MQMC uses multiple category-aware MoCo queues for bidirectional microvideo-product retrieval (Du et al., 2022). CmOS combines multimodal chain-of-thought and retrieval-augmented generation for educational MCQs with visual options (Wang et al., 26 Aug 2025). These systems are adjacent only at the level of acronymic similarity.

Taken together, the term MoCQ functions less as a canonical method name than as a field-local shorthand. In queueing theory it denotes an exact, multi-branched moment method for product-form networks (0902.3065). In software security it denotes a neuro-symbolic loop for LLM-generated static-analysis queries (Li et al., 22 Apr 2025). In MoE quantization, it appears in at least one technical summary as a label overlapping with MoQa (Zheng et al., 27 Mar 2025). Any precise use therefore requires the disciplinary qualifier.