How Voice AI Understands Spelling Names, Emails, and Alphanumeric Codes Over the Phone

The Telephony Audio Ambiguity Problem:

Caller Speaks on 8kHz Phone Line: "My last name is P-E-T-E-R-S-O-N"
                                  │
                                  ▼
Frequency Cutoff at 3,400Hz (Muffled Audio)
- Plosive letters ("P" vs "B" vs "D") share identical 200Hz voice bar.
- Fricative letters ("S" vs "F") lose their 5,000Hz friction signature.
                                  │
                                  ▼
Legacy Speech Recognizer: Transcribes "B-E-T-E-R-F-O-N" (FAILED)
Modern Character-Level Neural ASR: Transcribes "P-E-T-E-R-S-O-N" (SUCCESS)

The 3-Step Alphanumeric Transcription Engine:

[Caller Speaks]: "My email is john dot smith ninety nine at gmail dot com"
                                 │
                                 ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 1. Acoustic Phonetic Tokenization (<30ms)                              │
│    - Converts spoken words ("dot", "at", "underscore") into syntax:    │
│      "dot" ──► ".", "at" ──► "@", "dash" ──► "-"                       │
└────────────────────────────────────────────────────────────────────────┘
                                 │
                                 ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 2. Contextual Grammar & Domain Validation Constraint                   │
│    - Verifies top-level domain (.com, .org, .io)                       │
│    - Matches local-part against standard email regex                   │
│    - Output: "john.smith99@gmail.com"                                  │
└────────────────────────────────────────────────────────────────────────┘
                                 │
                                 ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 3. Instant Conversational Verification Readback                        │
│    - AI speaks: "I have that as john dot smith 99 at gmail dot com.     │
│      Did I get that right?"                                            │
└────────────────────────────────────────────────────────────────────────┘

Phonetic Disambiguation Protocols:

Ambiguous Letter Pairings Over 8kHz Telephony:
- "B" vs "D" (Plosive similarity)
- "M" vs "N" (Nasal similarity)
- "S" vs "F" (Fricative bandwidth cutoff)
- "P" vs "T" (Unvoiced stop similarity)

The AI Adaptive Verification Script:
If the acoustic confidence score for a character drops below 85%:
- AI speaks: "To make sure I have that exactly right, was that 'B as in Boy' or 'D as in David'?"
- Caller responds: "B as in Boy!"
- AI locks in character 'B' with 100% certainty.

import asyncio
import re

class SpokenAlphanumericNormalizer:
    """
    Normalizes spoken telephone utterances containing spelled letters,
    email addresses, and numbers into clean structured data fields.
    """
    def __init__(self):
        self.symbol_map = {
            r"\bdot\b": ".",
            r"\bat\b": "@",
            r"\bunderscore\b": "_",
            r"\bdash\b": "-",
            r"\bhyphen\b": "-"
        }
        self.number_words = {
            "zero": "0", "one": "1", "two": "2", "three": "3", "four": "4",
            "five": "5", "six": "6", "seven": "7", "eight": "8", "nine": "9"
        }

    async def normalize_spoken_email(self, utterance: str) -> str:
        """Converts spoken text into valid email syntax in <5ms."""
        await asyncio.sleep(0.005)
        text = utterance.lower()

        # Replace spoken symbols
        for pattern, replacement in self.symbol_map.items():
            text = re.sub(pattern, replacement, text)

        # Replace spoken numbers
        for word, digit in self.number_words.items():
            text = re.sub(rf"\b{word}\b", digit, text)

        # Strip remaining whitespace around syntax
        normalized = "".join(text.split())
        print(f"[Email Normalizer]: '{utterance}' -> '{normalized}'")
        return normalized

if __name__ == "__main__":
    normalizer = SpokenAlphanumericNormalizer()

    async def run_tests():
        sample1 = "sarah dot connor seventy seven at outlook dot com"
        email1 = await normalizer.normalize_spoken_email(sample1)

        sample2 = "alex underscore smith nine nine at gmail dot com"
        email2 = await normalizer.normalize_spoken_email(sample2)

    asyncio.run(run_tests())