MetaGlyph: Math Symbols Instead of Wordy Instructions

Basic structure:

{input_data} → {action} where {constraints}

Constraint operators (combinable): - ∈(category) — belongs to the category - ¬(category) — does NOT belong to the category
- ∩ between conditions — both conditions at once

Action operators: - → — transform/execute - ⇒ — if-then rule - ◦ — sequence of operations

Task: You're putting together a pitch for an e-commerce startup. From a list of investors, you need the ones who invest in e-commerce and B2C but don't focus on enterprise solutions.

Regular prompt (215 tokens):

From the list of investors, select those who invest in the e-commerce segment and work with B2C models, but who do not specialize in enterprise solutions. Present the result as JSON with the following fields: investor name, fund, specialization. Do not include explanations, only structured data.

List of investors: [your list]

MetaGlyph prompt (41 tokens):

investors → select where ∈(e-commerce) ∩ ∈(B2C) ∩ ¬(enterprise) → JSON{name, fund, focus}

List: [your list]

Result: The model will return JSON listing the investors that pass all three conditions: they do e-commerce AND B2C AND NOT enterprise. The format will be the same as with the wordy prompt (75% agreement on Gemini, 100% accuracy on Kimi), but you spent 5x fewer tokens — meaning 5x less money on the API or a 5x faster response.

LLMs are bad at parsing wordy constraints in prose. The phrase "select those who do e-commerce and B2C but not enterprise" is ambiguous about the scope of the negation. Does "not" apply only to enterprise, or to the combination? The model guesses from context.

LLMs know mathematical symbols really well from their training data — millions of pages of math, code, and formal logic. The symbol ∈ consistently means "belongs to a set," ¬ consistently means "negation," ∩ consistently means "intersection." These meanings are locked in by a huge volume of texts where the symbols are used the same way.

MetaGlyph taps into this stable semantics: instead of a 20-word phrase, you get 3 symbols the model already understands. It doesn't guess the meaning from word positions — it pulls the ready-made meaning from what it learned in training.

Control levers:

• Operator choice — ∈ works best (91.3% on GPT), ⇒ is excellent on Kimi (98.1%), ∩ barely works — test on your model and pick the ones that work
• Hybrid — you can mix symbols + words: ∈(e-commerce startups from Europe) — the model will understand the combination
• Nesting — for complex rules, use parentheses: (∈(tech) ∩ ¬(hardware)) ∪ ∈(AI) — "either software without hardware, or AI"

{data} → {action} where {constraints} → {output_format}

Basic operators: - ∈(category) — is in the category - ¬(category) — is NOT in the category - ∩ — AND (both conditions) - ∪ — OR (either condition) - → — transform/execute - ⇒ — if-then rule

Example values:

{data} = products, candidates, risks, investors
{action} = select, extract, filter, rank
{constraints} = ∈(tech) ∩ ¬(hardware), ∈(senior) ∩ ∈(remote)
{output_format} = JSON{name, status}, list, summary

For conditional (if-then) rules:

{data} → apply: {condition} ⇒ {action} → {format}

Example: employees → apply: ∈(admin) ⇒ access=full, ∈(user) ⇒ access=limited → JSON

🚀 Quick start — paste into the chat:

Here is a MetaGlyph template for compressing prompts. Adapt it to my task: [your task]. 
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask what data you're filtering, which categories matter, and what output format you need — it'll take the symbolic structure from the template and plug in your parameters. You'll get a working symbolic prompt without building it by hand.

The problem with wordy instructions:

When you write "select the items that belong to the mammal category and are pets but are not birds," the model has to: 1. Find the boundaries of each condition 2. Figure out how they're connected ("and" vs "or") 3. Determine the scope of the negation (what does "not" apply to?)

Each phrase is a little ambiguous, and the model relies on statistics about word positions. Sometimes it guesses right, sometimes not.

The power of math symbols:

Symbols like ∈, ¬, ∩ appear in LLM training data millions of times — in math textbooks, logic papers, and Python/Julia/Haskell code. In all these contexts they mean the same thing: - x ∈ S = "x belongs to set S" - ¬P = "not P"
- A ∩ B = "both A and B at once"

This consistency of meaning across contexts creates a strong association in the model's weights. When it sees ∈(mammal), it activates the "membership filter" pattern it has seen in thousands of examples.

How MetaGlyph uses this:

Instead of a wordy phrase with implicit structure, you give it explicit structure through symbols:

∈(mammal) ∩ ∈(pet) ∩ ¬(bird)

The model parses this as a familiar pattern: - Three conditions - Two positive (∈) - One negative (¬) - All joined by "AND" (∩)

The ambiguity disappears. The model doesn't guess the structure — it reads it off the symbols.

Why the control matters:

The researchers swapped the symbols for meaningless ones (⊙, ⊗, ⊕) and got 0% agreement with plain language. That means models respond not to "looks like a formula" but to the specific meanings of ∈, ¬, ∩. These symbols are not just decoration — they carry semantics the model absorbed from data.

⚠️ Uneven operator support: The ∩ (intersection) operator barely works — models show close to 0% correct understanding. GPT-5.2 reaches 21.4%, which is still weak. Why: in math texts ∩ joins sets, but here it has to join predicates (conditions) — a transfer the models haven't learned.

⚠️ Model dependence: Results vary a lot. Gemini is good for selection (75% equivalence), Kimi for conditional rules (98.1% fidelity on ⇒), GPT for filtering (91.3% fidelity on ∈), Claude for format reliability (100% parse success). Test on your target model — what works on one may not work on another.

⚠️ A U-shaped curve by model size: Small models (3B) show moderate symbol understanding (33% fidelity), mid-size ones (7-12B) drop to 0% — instruction tuning creates a bias toward prose — and large (frontier) models recover and outperform the small ones. If you're using mid-size open-source models (7-12B), symbolic prompts won't work.

⚠️ Output-format sensitivity on complex tasks: GPT-5.2 shows 99% parse success on simple selection tasks, but wraps answers in markdown (```json) on complex extraction and constraint-composition tasks, which breaks JSON parsing. Claude is the opposite — 100% parse success on every task type, but lower operator fidelity. For complex tasks, pick a model with reliable formatting.

The researcher tested the idea on eight models from 3B to 1T parameters — from open-source (Llama, Qwen, OLMo, Gemma) to proprietary APIs (Gemini, Claude, GPT, Kimi). Two dimensions were chosen: size (affects capability) and access (local run vs API).

For each task they created three prompt versions on the same data: 1. Natural Language — wordy prose (172 tokens on average) 2. MetaGlyph — math symbols (51 tokens on average) 3. Control — meaningless symbols in place of the math ones (⊙, ⊗, ⊕) — same length as MetaGlyph

The control is the key trick of the experiment. If MetaGlyph and Control had produced similar results, it would mean models respond to "looks mathy" rather than meaning. But Control gave 0% agreement with plain language on all working models — so models feel the difference between ∈ and ⊙. The symbols work through learned semantics, not form.

They tested four task types: selection (picking by criteria), extraction (pulling out structured data), constraint composition (applying several constraints at once), conditional transformation (if-then rules and operation sequences). Each type stresses different operators.

A surprising finding: Kimi K2 hit 100% accuracy on selection tasks with symbolic prompts versus 90.8% with plain prose. Symbolic prompts aren't just equivalent — they can work better. The researcher's explanation: the explicit structure removes the ambiguity that hurts prose.

The second counterintuitive result: mid-size models (7-12B parameters) showed worse symbol understanding than small ones (3B). Llama 3B: 33.3% fidelity on ∈, Gemma 12B: 0%. Hypothesis: instruction tuning on large volumes of prose creates an anti-symbol bias that small models haven't picked up yet and huge (frontier) models overcome through scale. A U-shaped curve: small models are naive but flexible, mid-size ones are overtrained on prose, and big ones are powerful enough to activate both prose patterns and symbol patterns at once.

Three metrics were measured: semantic equivalence (how often MetaGlyph and NL produce identical output), operator fidelity (whether each operator works as intended — e.g. ∈ correctly filters into the specified category), compression ratio (how many tokens were saved). Results: 62-81% compression depending on task type, 75% equivalence on the best model-task combo (Gemini + selection), 91.3% fidelity for the ∈ operator on GPT-5.2.

Context: These are prompt examples from the experiment — the original Natural Language, MetaGlyph, and Control versions for a selection task (picking items by criteria).

Natural Language prompt:

Select items from the list that belong to the category of mammals, that belong to the category of pets, and that do not belong to the category of birds. Return the result as JSON with fields: item, category, is_selected. Do not include explanations.

Items: [dog, cat, parrot, hamster, eagle, rabbit]

MetaGlyph prompt:

items → select where ∈(mammal) ∩ ∈(pet) ∩ ¬(bird) → JSON{item, category, is_selected}

Items: [dog, cat, parrot, hamster, eagle, rabbit]

Control prompt (meaningless symbols):

items ⊙ select where ⊗(mammal) ⊕ ⊗(pet) ⊕ ◊(bird) ⊙ JSON{item, category, is_selected}

Items: [dog, cat, parrot, hamster, eagle, rabbit]

Results for Gemini 2.5 Flash: NL and MetaGlyph produced identical output in 75% of cases. Control gave 0% agreement with NL — confirmation that the model responds to the meaning of ∈, ∩, ¬, not just to "looks like a formula."

A hybrid approach for critical constraints

💡 Technique: symbols + keywords → lower risk of errors

If the task is high-stakes (finance, legal, medical), you can mix symbols for structure with prose for the important conditions:

candidates → select where ∈(senior developer) ∩ ∈(remote work REQUIRED) ∩ ¬(relocation required) → JSON{name, level, location_type}

All caps and repetition in prose reinforce the critical constraint, while the symbols hold the structure. The model gets two signals for the important condition — through ∈ and through "REQUIRED."

Adaptation for complex conditional rules

💡 Adaptation for multi-step business logic:

The ⇒ (implication) operator shows 98.1% fidelity on Kimi K2 — nearly perfect. Use it for complex if-then rules:

orders → process:
∈(new_customer) ⇒ discount=15% ◦ priority=medium
∈(returning_customer) ∩ amount>$1,000 ⇒ discount=25% ◦ priority=high
∈(returning_customer) ∩ amount<$1,000 ⇒ discount=10% ◦ priority=medium
→ JSON{client_id, discount, priority}

The ◦ (composition) symbol indicates a sequence of actions. Kimi K2 reads ⇒ as "if the condition on the left, then the action on the right" — a powerful tool for business rules.

Technique: nested parentheses for complex logic

🔧 Technique: parentheses → explicit grouping of conditions

The ∩ (intersection) operator works poorly at the top level, but it may work inside parentheses for grouping:

products → filter where (∈(tech) ∩ ¬(hardware)) ∪ (∈(AI) ∩ ∈(B2B)) → list

Reads as: "either (software without hardware) or (AI for business)." The parentheses give the model explicit grouping. No guarantee — ∩ is still a weak spot — but the structure can help.

Adaptation for API savings at high volume

💡 Adaptation for bulk API requests:

If you're making thousands of requests to GPT/Claude/Gemini, swapping wordy instructions for symbols means direct cost savings:

Before: 215 instruction tokens × 5000 requests = 1,075,000 tokens
After: 41 tokens × 5000 requests = 205,000 tokens
Savings: 870,000 tokens = 80.9%

At $0.15 per 1M tokens (Claude Haiku), that's a saving of $0.13 — sounds tiny, but over millions of requests it adds up to real money. Plus latency: fewer tokens = faster processing.

For bulk tasks like classifying requests, screening resumes, or extracting data from documents, symbolic prompts pay for themselves through volume.

Semantic Compression of LLM Instructions via Symbolic Metalanguages
Ernst van Gassen, Independent Researcher
The OpenRouter API was used to access proprietary models
Open-source models: Llama (Meta), Qwen (Alibaba), OLMo (Allen Institute for AI), Gemma (Google)