Semantic Regexes

• Semantic regexes are a family of enhanced regular expressions that combine syntactic pattern matching with semantic reasoning, using predicates, oracles, and structured synthesis.
• They enable accurate data extraction and pattern synthesis from natural language and examples through methods like sketch-guided synthesis and oracle-augmented matching.
• Applications span OCR, cybersecurity, and LLM feature interpretation, highlighting both practical performance gains and challenges in testing and engine consistency.

Searching arXiv for papers on semantic regular expressions and closely related formulations. arXiv.search(query="semantic regular expressions regex semantics synthesis examples oracle SMORE", max_results=10) Semantic regexes are regular-expression formalisms and synthesis frameworks in which matching is not treated as purely syntactic character-level pattern recognition. In the current literature, the phrase covers several related uses: regexes inferred from natural language and examples, regex languages extended with semantic predicates or external oracles, practical regex formalisms whose behavior depends on captures, backreferences, lookarounds, and priority rules, and structured description languages that use regex-like composition to encode higher-level concepts rather than raw strings (Ye et al., 2019, Chen et al., 2023, Huang et al., 2024, Boggust et al., 7 Oct 2025). A common thread is that the intended meaning of a pattern is carried by more than surface syntax alone.

1. Scope of the term

The literature does not use semantic regexes for a single standardized syntax. Instead, it uses the term for multiple technical programs that all attach additional meaning, structure, or operational semantics to regex-like objects. This suggests that the term is best understood as a family of approaches rather than a single formalism.

Usage	Defining mechanism	Representative notation
Synthesis from specifications	Sketches, holes, examples, repairs	{S1,...,Sm}, _d{...}
Semantic matching	Typed predicates or oracle checks	\{ v:\tau \mid \phi \}, r \land q
Practical engine semantics	Ordered choice, captures, lookarounds, priorities	?(E), !(E), (E)_v
Extraction and description	Span extraction or structured semantic primitives	#x{\alpha}, [:field X:]

In semantic data extraction, the added meaning comes from a construct such as $\{ v: \tau \mid \phi \}$, which matches strings that are semantically of type $\tau$ and satisfy predicate $\phi$ (Chen et al., 2023). In SemRE membership, the added meaning comes from the constructor $r \land q$, interpreted through an external oracle $\mathbb{O} : Q \times \Sigma^* \to Bool$ (Huang et al., 2024). In practical regex semantics, meaning is tied to engine behavior: ordered alternatives, greedy or lazy repetition, capturing groups, and lookarounds are part of the semantics rather than merely syntax (Medeiros et al., 2012). In document spanners, a regex with capture variables does not merely recognize strings; it extracts relations of spans from text (Freydenberger et al., 2017). In automated interpretability, semantic regexes are a structured language built from primitives such as [:symbol X:], [:lexeme X:], and [:field X:], together with contextualization, composition, and quantification (Boggust et al., 7 Oct 2025).

A recurring misconception is that semantic regexes are only about external semantic predicates. The broader record is more heterogeneous: some papers use the term for semantic enrichment of matching, others for semantic synthesis from user intent, others for engine-faithful operational semantics, and others for structured semantic descriptions.

2. Synthesis from language, examples, and latent structure

A major line of work treats semantic regex generation as an overview problem in which language is incomplete and examples resolve ambiguity. “Sketch-Driven Regular Expression Generation from Natural Language and Examples” explicitly frames regex generation as a two-stage semantic synthesis problem: a semantic parser maps natural language into an intermediate sketch with holes, and a program synthesizer fills those holes using positive and negative examples (Ye et al., 2019). The regex DSL includes StartsWith(S), EndsWith(S), Contains(S), Optional(S), Repeat(S,k), KleeneStar(S), RepAtLeast(S,k), RepRange(S,k1,k2), Concat(S,S), And(S,S), and Or(S,S), and the sketch language adds the constrained-hole form {S1,...,Sm}. The paper stresses that such holes are a soft structural constraint rather than a rigid skeleton. On KB13 and Turk, DeepSketch with MML and pseudogold sketches achieves 86.4% and 86.2% accuracy, with 96.3% and 98.9% consistency; on the StackOverflow dataset it solves 57% of the real-world dataset, whereas the transferred DeepRegex model has 0% top-1 accuracy (Ye et al., 2019).

“Multi-modal Synthesis of Regular Expressions” implements the same broad idea in REGEL, where English is parsed into a ranked hierarchical sketch and a sketch-guided PBE engine completes it using positive and negative examples (Chen et al., 2019). On 322 regex tasks, REGEL solves 80% of the 322 benchmarks, compared to 43% for the NLP-only baseline and 26% for the PBE-only baseline. The paper also reports that the PBE engine is about 10× faster than the AlphaRegex-based adaptation on the first 1000 sketches solved by all variants, and the user study with 20 participants found 73.3% success with REGEL versus 28.3% without it (Chen et al., 2019).

“TransRegex: Multi-modal Regular Expression Synthesis by Generate-and-Repair” recasts the problem as NLP-based synthesis with regex repair (Li et al., 2020). The pipeline first generates a full regex from natural language using $\mathrm{S_2RE}$ and then repairs it with examples using $\mathrm{SynCorr}$ and, if needed, $\mathrm{RFixer}$. The reward is explicitly split between semantic correctness and syntactic validity, $R(r)=\alpha R_C(r)+\beta R_V(r)$ with $\alpha=\beta=0.5$. On KB13, NL-RX-Turk, and StructuredRegex, the combined pipeline reaches 95.6% / 98.6% / 67.4%, outperforming prior multimodal methods by roughly 10–30% across datasets (Li et al., 2020).

A complementary example-only perspective appears in “Bayesian Inference of Regular Expressions from Human-Generated Example Strings,” which models regex induction as Bayesian inference over a probabilistic regular grammar (Ouyang, 2018). The posterior objective is

$\tau$0

and the paper introduces a stochastic process recognition model that incrementally “grows” a grammar from positive examples. The authors report that SMC-based methods performed best and that the algorithm is competitive with human ability to learn regexes from examples (Ouyang, 2018).

Across these systems, the central methodological shift is the same: regex intent is treated as a latent structured object, not as a string to be emitted in one shot. Examples are not merely a post-hoc filter; they are part of the actual search or repair process.

3. Typed and oracle-augmented semantic matching

A second line of work extends the regex formalism itself so that matching can invoke semantic types, predicates, or external oracles. In “Data Extraction via Semantic Regular Expression Synthesis,” semantic regexes are introduced as a generalization of regular expressions for data extraction tasks that require both syntactic pattern matching and semantic reasoning (Chen et al., 2023). The central construct is

$\tau$1

which matches strings that are semantically of type $\tau$2 and satisfy predicate $\tau$3. The DSL also supports transformations such as toUpper, toLower, and abbreviate[c], and uses both built-in and user-defined types. The Smore system combines neural sketch generation with compositional type-directed synthesis, and on 50 tasks across 10 datasets it reports 48/50 finished tasks, 0.94 precision, 0.84 recall, and 0.87 F1, while the best baseline numbers in the comparison are lower on all three metrics (Chen et al., 2023).

“Membership Testing for Semantic Regular Expressions” studies a closely related but formally distinct model, where semantic regular expressions, or SemREs, are defined over a finite alphabet $\tau$4, a query space $\tau$5, and an oracle

$\tau$6

The grammar is

$\tau$7

and the new constructor $\tau$8 means “match $\tau$9, and additionally require that the whole matched string satisfies oracle predicate $\phi$0” (Huang et al., 2024). The paper gives a two-pass NFA-based algorithm using a semantic NFA and a query graph, with worst-case time

$\phi$1

or

$\phi$2

when oracle queries are not nested. It also proves an $\phi$3 lower bound on the number of oracle queries necessary in the finite-$\phi$4 setting, reports about $\phi$5 higher throughput than the DP baseline, 51% fewer oracle calls, and a measured overhead of roughly $\phi$6 beyond the time spent in the oracle (Huang et al., 2024).

These two formalisms differ in implementation strategy. Smore uses a typed synthesis language with semantic predicates and neural semantic typing; SemRE membership uses oracle-refined matching and analyzes its algorithmic complexity. Their shared claim is narrower and more concrete: many extraction tasks require the text to be syntactically segmented and then semantically validated.

4. Operational semantics, expressivity, and safe matching

Another important sense of semantic regexes concerns the actual meaning of practical regex engines. “From Regexes to Parsing Expression Grammars” starts from the observation that scripting-language regex libraries borrow regex syntax but implement an informal semantics with ordered alternatives and greedy repetition, so the classical set-based semantics of regular expressions is not the right model (Medeiros et al., 2012). The paper formalizes regexes by translating them to PEGs, where ordered choice is explicit and matching is deterministic and prefix-based. Its thesis is that PEGs give practical regex behavior a formal meaning and a clearer computational model.

“Regular Expressions, au point” gives a different foundational semantics: a pointed regular expression is a regex whose points mark “the positions inside the regular expression which have been reached after reading some prefix of the input string” (Asperti et al., 2010). The semantic language $\phi$7 turns points into residual languages, and the operation $\phi$8 updates the state after one input symbol, with the correctness property

$\phi$9

This yields a DFA whose states are pointed expressions with the same carrier, making the regex itself a stateful semantic object rather than a static language descriptor (Asperti et al., 2010).

For real-world features, the formal boundary is much broader. “Regular Expressions with Backreferences and Lookaheads Capture NLOG” defines REWBLk with captures (E)_v, backreferences v, positive lookahead ?(E), and negative lookahead !(E), and proves that REWBLk coincides with NLOG and that the membership problem of REWBLk is PSPACE-complete (Uezato, 2024). The paper identifies negative lookaheads as the technically hardest case and uses the Immerman–Szelepcsényi theorem to handle complement reasoning in nondeterministic log space.

“Repairing DoS Vulnerability of Real-World Regexes” shifts the focus from language expressivity to engine-faithful cost semantics (Chida et al., 2020). It defines an operational matching relation $r \land q$0 for real-world backtracking regexes with capturing groups, backreferences, lookaheads, and fixed-string lookbehinds. Vulnerability is then defined by derivation-tree size:

$r \land q$1

and a regex is vulnerable if $r \land q$2. The paper introduces real-world strong 1-unambiguity (RWS1U) and proves: A regex that satisfies RWS1U is invulnerable (Chida et al., 2020). It also formulates the corresponding PBE repair problem and proves that the RWS1U repair problem is NP-hard.

“Linear Matching of JavaScript Regular Expressions” studies this same semantic territory from the algorithmic side, arguing that JavaScript regexes are not just regular expressions with extra syntax but a distinct matching language with priority rules, capturing lookarounds, unbounded lookarounds, capture reset in quantifiers, and nullable quantifier semantics (Barrière et al., 2023). The paper gives linear-time constructions for a much larger subset of JavaScript regexes than prior work supported, including the first nonbacktracking linear-time algorithms for lookarounds, and reports worst-case

$r \land q$3

time for the supported fragments (Barrière et al., 2023).

Taken together, these papers show that the semantics of practical regexes is not exhausted by the denoted language. Matching policy, captures, lookarounds, and engine behavior are part of the meaning.

5. Extraction, transduction, and query answering over text

In information extraction, semantic regexes appear as devices that produce structured outputs rather than Boolean matches. “Joining Extractions of Regular Expressions” studies regexes with capture variables, also called regex formulas, in the document spanner framework (Freydenberger et al., 2017). A regex formula extends regular expressions with variable bindings $r \land q$4 and denotes a relation of spans over a string. The paper shows that lower bounds from relational query evaluation carry over—Boolean regex CQ evaluation is NP-complete, and the problem is W[1]-hard—but relational upper bounds do not, because even one regex atom may define an exponentially large relation. At the same time, the paper proves positive results: functional regex formulas compile in linear time to functional vset-automata, and regex $r \land q$5-UCQs can be evaluated with polynomial delay for fixed $r \land q$6, while regex UCQs admit FPT delay when parameterized by query size (Freydenberger et al., 2017).

“Solving String Constraints With Regex-Dependent Functions Through Transducers With Priorities And Variables” generalizes this perspective from extraction to full regex-dependent string functions in JavaScript (Chen et al., 2021). The key model is the Prioritized Streaming String Transducer (PSST),

$r \land q$7

which combines priorities to capture greedy and lazy semantics with string variables to model capturing groups and replacement behavior. The paper proves that pre-images of regular languages under PSSTs are regular and uses this in a sequent calculus for string constraints. Although the full language is undecidable, satisfiability of the straight-line fragment is decidable. The implementation extends OSTRICH with str.extract, str.replace_cg, and str.replace_cg_all, and on 98,117 real-world regexes collected from NPM packages it solves all queries for about 97% of the match files and about 91.5% of the replace files, with average times around 1.57 s and 6.62 s per file; compared with ExpoSE+Z3, it is roughly 8x–18x faster (Chen et al., 2021).

This extraction-and-transduction view shifts the emphasis from “does the string match?” to “what structured object does the regex compute?” In that sense, semantic regexes become query operators and transducers over text, not only recognizers.

6. Application domains: OCR, LLM interpretability, and CTI

Semantic regex ideas have also been applied as domain-specific priors and description languages. “Improving Structured Text Recognition with Regular Expression Biasing” uses regexes as a meaningful prior over what the OCR output should look like in structured-text recognition (Shi et al., 2021). The bias is implemented by compiling the regex into a WFST, weighting it via

$r \land q$8

and injecting it into the decoder through dynamic replacement. On driver-license fields, the best field WER is around 3.7% at $r \land q$9, a relative reduction of about 35% from the 5.5% full-dataset baseline; on passport MRZ, CER drops from 8.5% to about 5.4–5.5%; on the IAM names subset, the error drops from 36.0% to 10.3% at $\mathbb{O} : Q \times \Sigma^* \to Bool$0 (Shi et al., 2021). The paper emphasizes that the bias is soft rather than hard: matching outputs are preferred, but non-matching outputs remain possible.

“Semantic Regexes: Auto-Interpreting LLM Features with a Structured Language” uses the term in a different but formally explicit way: semantic regexes are structured language descriptions of LLM features (Boggust et al., 7 Oct 2025). The primitives are [:symbol X:], [:lexeme X:], and [:field X:], and the modifiers include context, sequence, alternation, and ?. The paper compares this language against two natural-language baselines, token-act-pair and max-acts, and reports that semantic regexes are non-inferior on clarity across all models. It also reports median description lengths of 41 characters for semantic regexes, 55 characters for token-act-pair, and 139 characters for max-acts, and consistency rates of 33.6% identical descriptions for semantic regexes versus 12.2% and 0.0% for the two baselines (Boggust et al., 7 Oct 2025). In a 24-person user study, participants scored higher with semantic regex descriptions on 9 of 12 features (Boggust et al., 7 Oct 2025).

“From IOCs to Regex: Automating CTI Operationalization for SOC with LLMs” applies semantic regex generation to cyber threat intelligence (Tseng et al., 14 Apr 2026). IOCRegex-gen converts file paths, registry keys, and command-line arguments into regexes through Capture Group Finding and Regex Generation, using a group-aware mechanism, a graph database of native OS structures, iterative debugging, non-capture validation, and candidate grading with

$\mathbb{O} : Q \times \Sigma^* \to Bool$1

where $\mathbb{O} : Q \times \Sigma^* \to Bool$2. On 3,156 CTI reports, over 230,000 sentences, and more than 63,000 IOC candidates, and with ground truth built from over 2,400 strings from the MITRE ATT&CK Evaluation framework, the paper reports an average hit rate of 99.1% and an average false-positive rate of 0.8% (Tseng et al., 14 Apr 2026).

These applications differ sharply in domain, but all use regex structure as a carrier for meaning: document format priors in OCR, normalized feature descriptions in interpretability, and operational intent in SOC workflows.

7. Portability, testing, and the limits of a universal semantics

A final theme is that semantic regexes are difficult precisely because regex semantics is fragmented across languages and engines. “Why Aren't Regular Expressions a Lingua Franca?” studies 537,806 unique regexes from 193,524 software projects across 8 languages and concludes that developers’ belief in a regex lingua franca is “understandable but unfounded” (Davis et al., 2021). Although 92% of regexes are syntactically valid in most or all studied languages, 15.4% exhibit at least one semantic difference witness and 10% exhibit performance differences. The paper distinguishes match witnesses, substring witnesses, and capture witnesses, and explains the observed differences through feature divergence, “false friends,” undocumented behaviors, and engine bugs (Davis et al., 2021).

“Towards the Systematic Testing of Regular Expression Engines” extends this concern from portability to validation (Çakar et al., 27 Feb 2026). The paper argues that differential testing is a weak oracle because dialects diverge, and proposes ReTest, which combines grammar-aware fuzzing with metamorphic testing derived from Kleene algebra. It surveys testing practices across 22 regex engines, analyzes 1,007 regex engine bugs and 156 CVEs, and curates 16 metamorphic relations. Semantic bugs are the largest category at 35.3%, while memory bugs account for 11.4% of the bug study and 52% of CVEs (Çakar et al., 27 Feb 2026). On PCRE v8.45, ReTest reports 40.12% edge coverage versus 12.66% for V8-style grammar-aware fuzzing and 11.81% for OSS-Fuzz-style naive fuzzing, and identifies three new memory bugs (Çakar et al., 27 Feb 2026).

This suggests that semantic regex research has a dual obligation. One part is constructive: define richer pattern languages, synthesis procedures, or structured descriptions. The other part is forensic: establish what existing engines actually mean, where they diverge, and how to test whether an implementation respects the intended semantics.