bodhisattamaiti/EmojiSeqMutations

Dataset Card for EmojiSeqMutations

EmojiSeqMutations is a deterministic dataset of controlled Unicode-level transformations derived from fully-qualified emoji sequences in Unicode 17.0.0.

The dataset contains 16,914 records covering structural mutations involving Zero Width Joiners (ZWJ), variation selectors, emoji modifiers, and keycap sequences, together with controlled skin-tone modifier substitutions.

Each record preserves the original Unicode sequence, the transformed sequence, the exact code-point-level operation that produced it, Unicode metadata, provenance, and information about whether the transformation is uniquely invertible.

The dataset is generated programmatically from version-pinned Unicode data. It contains no LLM-generated labels and requires no manual annotation.

Dataset Details

Dataset Description

A single visible emoji may consist of multiple Unicode code points rather than a single character. For example, profession, family, gender, and skin-tone emoji may contain combinations of base characters, emoji modifiers, Zero Width Joiners (U+200D), variation selectors such as U+FE0F, and other structural components.

EmojiSeqMutations was created to provide controlled examples of what happens when these underlying Unicode sequences are modified.

For example:

Source:
👩🏽‍⚕️

Code points:
U+1F469 U+1F3FD U+200D U+2695 U+FE0F

Operation:
delete_zwj

Transformed:
👩🏽⚕️

Code points:
U+1F469 U+1F3FD U+2695 U+FE0F

The transformation is deterministic: the generator knows exactly which code point was changed, removed, or substituted.

Version 1 contains two high-level transformation categories:

• —`structural_mutation` — 7,134 records
• —`modifier_substitution` — 9,780 records

The six included mutation operations are:

The dataset uses Unicode 17.0.0 and mutation ruleset 1.0.

Standard flag emoji and Regional Indicator mutation families are intentionally excluded from V1.

• —Curated by: Bodhisatta Maiti
• —Funded by: No external funding
• —Shared by: Bodhisatta Maiti
• —Language(s) (NLP): Not language-specific; the dataset contains Unicode emoji sequences and associated metadata
• —License: CC BY 4.0 for this dataset release. The Unicode source data used to construct the dataset are separately governed by the Unicode License.

Dataset Sources

The source inventory and structural properties are derived from version-pinned Unicode 17.0.0 data published by the Unicode Consortium.

Primary source files:

• —emoji-test.txt
• —emoji-variation-sequences.txt
• —emoji-data.txt

The generator does not use /latest/ Unicode endpoints when constructing the released dataset. Version-specific Unicode 17.0.0 files are used to preserve reproducibility.

The Unicode source-file SHA-256 hashes used for this release are also recorded in manifest.json.

Unicode data files are distributed under the Unicode License. Users redistributing Unicode data or derived resources should retain the applicable Unicode copyright and permission notice in associated documentation.

• —Unicode source: Unicode Consortium, Unicode 17.0.0
• —Generation repository: To be added
• —Paper: None
• —Demo: None

Uses

Direct Use

EmojiSeqMutations is designed as a reusable Unicode robustness and transformation dataset rather than a benchmark tied to one specific model architecture.

Potential uses include:

Emoji sequence robustness

Evaluate whether text-processing systems preserve structurally significant Unicode characters such as Zero Width Joiners, variation selectors, and emoji modifiers.

Mutation classification

Given a source/transformed pair, predict the Unicode-level operation that occurred, such as:

delete_zwj
delete_vs16
replace_vs16_with_vs15
delete_modifier
delete_keycap_combiner
replace_modifier

Sequence reconstruction

For examples marked uniquely_invertible = true, users can evaluate whether a system can recover the unique source sequence from the transformed sequence.

There are 4,672 uniquely invertible records in V1.

Unicode reasoning for language models

The dataset can be used to evaluate whether an LLM understands the internal code-point structure of complex emoji rather than treating emoji only as opaque visual symbols.

Tokenizer analysis

Researchers can compare how tokenizers represent an original emoji sequence and its transformed counterpart.

Possible measurements include:

• —token count
• —byte/token fragmentation
• —token-ID changes
• —sensitivity to removal of invisible Unicode characters
• —differences across tokenizer families

Text-processing regression tests

Software libraries that perform normalization, sanitization, truncation, preprocessing, or text cleaning can use the dataset to check whether transformations inadvertently modify emoji structure.

Unicode-aware software testing

The deterministic transformations can serve as test fixtures for Unicode libraries, editors, messaging systems, parsers, databases, and other text-processing applications.

Controlled transformation research

replace_modifier provides controlled modifier substitutions such as:

👋🏻 → 👋🏼

These are transformations rather than necessarily malformed outputs and are therefore identified separately as modifier_substitution.

Out-of-Scope Use

The dataset should not be interpreted as a dataset of visually "good" versus "bad" emoji.

It does not provide subjective labels such as:

broken
ugly
incorrect rendering
easy
hard

The dataset is also not intended to model:

• —real-world emoji usage frequency
• —emoji sentiment or emotion
• —demographic behavior
• —semantic appropriateness of emoji in natural-language contexts
• —platform-specific appearance
• —font compatibility
• —user preference
• —emoji popularity
• —country-flag usage

A transformed sequence being absent from emoji-test.txt must not automatically be interpreted as meaning that the underlying Unicode string is invalid.

Similarly, source_emoji should not automatically be treated as the uniquely recoverable repair target. Multiple fully-qualified source sequences can sometimes generate the same transformed sequence.

Use uniquely_invertible and inverse_source_count when constructing repair tasks.

Dataset Structure

The dataset contains 16,914 rows.

No semantic train/validation/test split is prescribed. The dataset is intended to support multiple downstream formulations, so users are encouraged to create splits appropriate to their task.

For machine-learning evaluation, splitting by source sequence rather than randomly splitting individual rows is recommended when leakage between transformations of the same source could affect results.

Example Records

ZWJ deletion

source_emoji:       👩🏽‍⚕️
mutated_emoji:      👩🏽⚕️
mutation_category:  structural_mutation
mutation_operation: delete_zwj

Variation-selector deletion

source_emoji:       ❤️
mutated_emoji:      ❤
mutation_category:  structural_mutation
mutation_operation: delete_vs16

Variation-selector substitution

source_emoji:       ☺️
mutated_emoji:      ☺︎
mutation_category:  structural_mutation
mutation_operation: replace_vs16_with_vs15

Modifier substitution

source_emoji:       👋🏻
mutated_emoji:      👋🏼
mutation_category:  modifier_substitution
mutation_operation: replace_modifier

Fields

Inverse Ambiguity

Not every transformation can be uniquely reversed.

V1 contains:

The observed inverse_source_count values in V1 are:

1 → 4,672 records
4 → 6,940 records
5 → 1,880 records
6 → 1,542 records
8 → 1,880 records

This metadata allows users to construct strict sequence-repair subsets without assuming that every transformed sequence identifies a unique original.

Dataset Creation

Curation Rationale

Many emoji that appear visually as a single symbol are represented internally as sequences of multiple Unicode code points.

These sequences may contain structural elements such as:

• —Zero Width Joiner (U+200D)
• —Variation Selector-15 (U+FE0E)
• —Variation Selector-16 (U+FE0F)
• —Emoji modifiers
• —keycap combining characters
• —multiple emoji components

Small code-point-level changes may alter the structure or presentation of an emoji.

Despite this, many emoji datasets focus on rendered images, sentiment, descriptions, text-to-emoji prediction, or semantic classification.

EmojiSeqMutations instead focuses on the underlying Unicode sequence structure and provides deterministic, provenance-preserving transformations suitable for robustness testing and controlled evaluation.

Source Data

All V1 source emoji originate from fully-qualified entries in Unicode 17.0.0 `emoji-test.txt`.

The generator parsed 3,674 fully-qualified non-flag source emoji after applying the V1 scope rules.

Not every source generates a dataset record. A source is transformed only when at least one V1 mutation rule is structurally applicable.

Standard emoji in the Unicode Flags group are excluded from V1.

Data Collection and Processing

Dataset creation follows the deterministic pipeline:

Pinned Unicode 17.0.0 files
        ↓
Parse fully-qualified source emoji
        ↓
Exclude V1 out-of-scope groups
        ↓
Extract code-point structure
        ↓
Determine applicable mutation rules
        ↓
Apply controlled transformation
        ↓
Validate transformation invariants
        ↓
Lookup transformed Unicode status
        ↓
Calculate inverse ambiguity
        ↓
Write Parquet / CSV / manifest

The generator obtains skin-tone modifiers from the Unicode Emoji_Modifier property instead of maintaining a manually defined list.

VS15/VS16 substitutions are permitted only when the relevant variation sequence is defined in the pinned Unicode variation-sequence data.

Every generated row is validated programmatically.

Examples of automated invariants include:

• —source and transformed sequences must differ
• —code points must round-trip correctly through Unicode strings
• —a delete_zwj transformation must remove exactly one U+200D
• —a delete_vs16 transformation must remove exactly one U+FE0F
• —a modifier substitution must use Unicode Emoji_Modifier code points
• —all unrelated code points must retain their original ordering
• —generated identifiers must be unique
• —all source entries must be fully qualified
• —source entries from the Unicode Flags group must not appear
• —Unicode and ruleset versions must remain fixed across a release

The generator was initially tested with golden examples and subsequently validated against all generated records.

Included Mutation Rules

Ruleset 1.0 includes:

`delete_zwj`

Removes one selected Zero Width Joiner from an eligible source.

`delete_vs16`

Removes one selected U+FE0F emoji-presentation selector.

`replace_vs16_with_vs15`

Replaces U+FE0F with U+FE0E only when Unicode officially defines the corresponding text-style variation sequence.

`delete_modifier`

Removes one Unicode Emoji_Modifier code point.

`replace_modifier`

Replaces one Emoji_Modifier with each of the other official modifier alternatives.

`delete_keycap_combiner`

Removes U+20E3 from an eligible keycap sequence.

Rules involving arbitrary Unicode replacement, random insertion, arbitrary component permutation, Regional Indicator flag mutation, and deliberately duplicated ZWJs/modifiers are excluded from Ruleset 1.0.

Who are the source data producers?

The source Unicode character and emoji data were produced and maintained by the Unicode Consortium.

EmojiSeqMutations itself is a programmatically derived dataset constructed by applying deterministic transformation rules to version-pinned Unicode data.

Annotations

Annotation Process

There is no conventional human annotation process.

All transformation labels are generated deterministically by the dataset generator.

For example, if the generator removes U+200D, the corresponding record receives:

mutation_family: zwj
mutation_operation: delete_zwj

because the generator itself performed that operation.

Unicode qualification and variation-sequence metadata are obtained by exact lookup against the pinned Unicode 17.0.0 source data.

Inverse-ambiguity metadata is calculated from the completed generated dataset.

Who are the annotators?

There are no human annotators.

Annotations and transformation metadata are produced programmatically from:

1. 1.Unicode 17.0.0 source data, and
2. 2.deterministic mutation ruleset 1.0.

Personal and Sensitive Information

The dataset does not contain user-generated conversations, personal identifiers, accounts, addresses, or other private information.

The dataset consists of Unicode emoji sequences, code-point metadata, Unicode names/categories, deterministic transformations, and provenance information.

Bias, Risks, and Limitations

Unicode Version

V1 is explicitly tied to Unicode 17.0.0.

Future Unicode releases may add new emoji, sequences, or properties. Existing V1 records should therefore be interpreted according to Unicode 17.0.0.

The generator is designed to be version-aware so future releases can be generated separately without silently replacing V1.

No Real-World Frequency Distribution

The dataset enumerates structurally applicable transformations. It does not attempt to reproduce how frequently individual emoji or transformations occur in real-world messages.

Rows should therefore not be interpreted probabilistically.

Rendering Is Out of Scope

The dataset operates at the Unicode sequence level.

Actual visual rendering may differ across:

• —operating systems
• —fonts
• —browsers
• —messaging applications
• —shaping engines
• —vendor emoji implementations

A transformed sequence that is structurally interesting does not imply that all platforms will render it in the same way.

Visual Rendering Note

Some Unicode-level transformations, particularly variation-selector mutations, may not produce an obvious visual difference in every browser, font, or operating system.

For example, deleting U+FE0F (VS16) or replacing it with U+FE0E (VS15) changes the underlying Unicode sequence, but the rendered glyph may still appear visually similar or identical in some environments.

VS15 and VS16 request text and emoji presentation respectively, but actual rendering depends on implementation and font support.

EmojiSeqMutations therefore records code-point-level transformations and does not guarantee that every source/mutated pair will produce visibly distinct rendered glyphs.

emoji-test.txt Absence Does Not Mean Invalid Unicode

Some transformed sequences do not occur in Unicode emoji-test.txt.

This must not automatically be interpreted as meaning that the resulting Unicode string is invalid.

The dataset reports lookup results rather than imposing a binary valid/invalid label.

VS15 Sequences

Some VS15 transformations are legitimate defined Unicode variation sequences while not appearing as emoji qualification entries in emoji-test.txt.

The fields mutated_is_defined_variation_sequence and mutated_lookup_status should be used together with mutated_qualification.

Modifier Substitution

Modifier substitutions may map one fully-qualified emoji to another fully-qualified emoji.

They are therefore labeled modifier_substitution, not structural corruption.

Some modifier substitutions may produce sequences that are not listed as fully-qualified emoji. Users should inspect the Unicode-status metadata rather than assuming all modifier substitutions have identical status.

Inverse Ambiguity

Most V1 records are not uniquely invertible.

A transformed emoji may have been generated from multiple fully-qualified sources.

For strict repair/reconstruction tasks, filter:

dataset = dataset.filter(
    lambda row: row["uniquely_invertible"]
)

Flags Are Excluded

Standard Unicode flag emoji and Regional Indicator mutation operations are outside the scope of V1.

No Difficulty Labels

The dataset intentionally does not classify records as easy, medium, or hard.

Users can construct their own difficulty criteria from objective structural metadata such as sequence length, ZWJ count, modifier count, and mutation type.

Recommendations

Users should formulate tasks from the objective metadata rather than assuming that every transformation represents corruption.

For sequence-repair evaluation, use the uniquely_invertible subset unless the task explicitly supports multiple possible sources.

For machine-learning train/test experiments, users should consider grouping records by source_emoji or source_codepoints before splitting. Random row-level splitting may place closely related transformations of the same source sequence in both training and evaluation sets.

Users evaluating visual behavior should independently control the font, renderer, operating system, and application environment because rendering behavior is not annotated by this dataset.

Users comparing results over time should report both:

unicode_version
ruleset_version

to preserve reproducibility.

Citation

There is currently no accompanying paper.

If citing the dataset, please cite the Hugging Face repository and include the dataset version, Unicode version, and mutation ruleset version.

Suggested citation:

Maiti, Bodhisatta. EmojiSeqMutations, Version 1.0. Unicode source version: 17.0.0. Mutation ruleset version: 1.0. Hugging Face Dataset. https://huggingface.co/datasets/bodhisattamaiti/EmojiSeqMutations

BibTeX:

@dataset{maiti2026emojiseqmutations, author = {Maiti, Bodhisatta}, title = {EmojiSeqMutations}, year = {2026}, version = {1.0}, publisher = {Hugging Face}, url = {https://huggingface.co/datasets/bodhisattamaiti/EmojiSeqMutations}, note = {Unicode source version 17.0.0; mutation ruleset version 1.0} }

APA:

Maiti, B. (2026). EmojiSeqMutations (Version 1.0) [Data set]. Hugging Face. https://huggingface.co/datasets/bodhisattamaiti/EmojiSeqMutations

Glossary

Code point

A numerical value assigned to a Unicode character, conventionally written in forms such as U+1F600.

Emoji sequence

A sequence of one or more Unicode code points used to represent an emoji.

ZWJ

Zero Width Joiner (U+200D), an invisible Unicode character used in many emoji sequences to join components into a combined representation.

VS15

Variation Selector-15 (U+FE0E), used to request text-style presentation for eligible characters.

VS16

Variation Selector-16 (U+FE0F), used to request emoji-style presentation for eligible characters.

Emoji Modifier

A Unicode property used by the skin-tone modifier code points.

Fully-qualified emoji

An emoji sequence identified as fully qualified in the corresponding Unicode emoji-test.txt data.

Structural mutation

A controlled change to the underlying structure of an emoji sequence, such as deleting a ZWJ, variation selector, modifier, or keycap component.

Modifier substitution

Replacement of one Unicode Emoji_Modifier with another.

Uniquely invertible

A transformed sequence for which exactly one source sequence in this dataset produces that transformed sequence.

Inverse ambiguity

The condition where multiple source sequences in the dataset produce the same transformed sequence.

More Information

Reproducibility

This release is versioned along two independent dimensions:

Unicode version: 17.0.0
Ruleset version: 1.0

The Unicode version identifies the authoritative source repertoire and Unicode properties.

The ruleset version identifies the deterministic transformation methodology.

This distinction allows future releases to update Unicode inputs or mutation logic without making previous experiments irreproducible.

The accompanying manifest.json contains dataset statistics and SHA-256 hashes of the Unicode source files used for generation.

Dataset Files

The V1 release contains:

emoji_sequence_mutations_unicode17_v1.parquet
emoji_sequence_mutations_unicode17_v1.csv
manifest.json

Parquet is recommended for normal use.

Dataset Card Authors

Bodhisatta Maiti

Dataset Card Contact

For questions, issues, or corrections, please use the Community tab of the Hugging Face dataset repository.