Why Urdu Says 'Mujhe' When It Means 'I'

In Urdu, the word for “I” is not a fixed label. It depends on the case, and the case depends on the verb.

This is not an exotic complication. English does something similar with “I” and “me,” but only in pronouns. Urdu extends the pattern to the whole clause, and the result is a grammar that tells you who did what by changing the shape of the subject.

The simplest implementation: one pronoun, one case#

The naive object is a single form. A parser stores a pronoun once, with one case label, and expects the verb to agree with it.

# One pronoun, one case, subject agreement always.
PRONOUNS = {"main": "nom"}
 
def naive_agreement(pronoun: str, verb: str) -> dict:
    return {"subject": PRONOUNS.get(pronoun, "unknown"), "verb": verb}

Urdu breaks that function in a specific place. The subject's shape changes when the aspect changes. The verb's agreement target changes with the subject. A parser that assumes a fixed pronoun and a fixed agreement target mislabels ordinary sentences.

Bottleneck: the pronoun is a slot in a case system, not a label for a person. Case is assigned by the clause, and the clause is determined by aspect and transitivity.

The basic sentence#

Urdu is a subject–object–verb language. The verb comes last. Postpositions come after the noun. Agreement is with the subject in the ordinary case:

میں کتاب پڑھتا ہوں main kitāb parhtā hūn I read the book. (habitual)

Here main is the nominative “I.” The verb parhtā is masculine singular, agreeing with main, and hūn is the first-person singular auxiliary.

Now change the aspect to perfective:

میں نے کتاب پڑھی main ne kitāb parhī I read the book. (completed)

The subject is now main ne, often written maine. The verb parhī is feminine singular, agreeing with kitāb, not with the speaker. The subject has taken a marker, and the verb has stopped agreeing with it.

This is the core of Urdu's split ergativity.

from dataclasses import dataclass
 
@dataclass(frozen=True)
class Clause:
    subject_form: str   # "main" or "main ne"
    verb: str
    agrees_with: str    # "subject" or "object"
 
NE_MARKER = " ne"
 
def has_ne(subject_form: str) -> bool:
    return subject_form.rstrip().endswith(NE_MARKER) or subject_form == "maine"
 
def expected_agreement(subject_form: str, perfective: bool, transitive: bool) -> str:
    if perfective and transitive and has_ne(subject_form):
        return "object"
    return "subject"

The function is the whole diagnosis. When the subject carries ne in a perfective transitive clause, agreement falls on the object. When ne is absent, agreement falls on the subject.

What ergativity means#

In a nominative–accusative language like English, the subject of a transitive verb and the subject of an intransitive verb look the same. “I saw him” and “I went” both use “I.” The object is the odd one out.

In an ergative–absolutive language, the subject of an intransitive verb and the object of a transitive verb pattern together. The subject of a transitive verb is the odd one out, marked differently.

Urdu is not fully ergative. It is split ergative: the ergative pattern appears only in perfective transitive clauses. In the imperfective, the ordinary nominative pattern returns.

Compare:

میں گیا main gayā I went.

The verb is intransitive, so there is no ne. The subject is main, and the verb agrees with it.

میں نے خط لکھا main ne khat likhā I wrote the letter.

The verb is transitive and perfective. The subject takes ne, and the verb agrees with khat, which is masculine singular. If the object were feminine, the verb would take the feminine form:

میں نے کتاب پڑھی main ne kitāb parhī I read the book.

The ne is not a preposition with a single meaning. It is a case marker that appears on the agent of a perfective transitive clause. It is a fossil of an older construction: the perfective participle was originally resultative, and the agent was expressed obliquely. Over time, the oblique agent became the normal subject of the perfective transitive.

# Object marking changes agreement. ko marks definite/animate objects;
# the verb then falls back to masculine singular default.
KO_MARKER = " ko"
 
def object_marked(obj: str) -> bool:
    return obj.rstrip().endswith(KO_MARKER)
 
def verb_agreement(subject_form: str, obj: str, perfective: bool,
                   transitive: bool) -> str:
    if perfective and transitive and has_ne(subject_form):
        if object_marked(obj):
            return "default_masculine_singular"
        return "object"
    return "subject"
 
def standard_agreement(*_a, **_k) -> str:
    raise NotImplementedError("replaced by verb_agreement above")

What happens when the object is marked#

Urdu objects can take ko, especially when they are definite, animate, or specific. When the object is marked, the verb does not agree with it. It falls back to a default masculine singular:

میں نے اسے دیکھا main ne use dekhā I saw him / her.

Here use is the dative/accusative form of woh (us plus the object marker ko), and the verb dekhā is masculine singular. The object is marked, so there is no object agreement. The clause is still ergative: the subject carries ne.

This is a useful diagnostic. If the verb agrees with the object, the object is unmarked. If the verb is masculine singular and the object is marked, the agreement has defaulted. Neither pattern is random; both follow from the case system.

def diagnose(subject_form: str, obj: str, verb_form: str,
             perfective: bool, transitive: bool) -> str:
    predicted = verb_agreement(subject_form, obj, perfective, transitive)
    return f"predicted agreement: {predicted}; observed verb: {verb_form}"

The diagnostic separates two questions that a naive parser merges: who is marked, and who is agreed with. Both are clause-level facts, not pronoun-level facts.

Mujhe is a different pattern#

The form mujhe is the oblique/dative of main. It appears in experiencer constructions, where the subject is not an agent but a recipient of a state:

مجھے بھوک لگی ہے mujhe bhūkh lagī hai I am hungry. (literally: hunger has struck me)

مجھے معلوم ہے mujhe ma‘lūm hai I know. (literally: it is known to me)

مجھے کتاب پسند ہے mujhe kitāb pasand hai I like the book. (literally: the book is pleasing to me)

These are not ergative clauses. There is no ne, and there is no transitive agent in the same sense. The person is an experiencer, and the clause is organized around a state rather than an agent. The hunger, the book, the fact — those occupy the subject position; the person does not. English translates all of these with “I,” which hides the difference. Urdu keeps the person in an oblique case and lets the state be the subject.

OBLIQUE = {"main": "mujhe", "tum": "tumhe", "woh": "use"}
 
def experiencer_form(pronoun: str) -> str:
    return OBLIQUE.get(pronoun, pronoun)
 
def is_experiencer(subject_form: str, predicate: str) -> bool:
    # Experiencer: oblique person + state predicate, no ne, no agent verb.
    return subject_form in OBLIQUE.values() and predicate in {
        "bhukh", "malum", "pasand",
    }

Step 1: replace a single pronoun label with a case table. The test is the perfective pair above. A case table maps main to mujhe in the experiencer pattern and to main ne in the perfective transitive pattern. A fixed label fails both.

Step 2: branch agreement on aspect and marking. The verb_agreement function does this. A parser that always agrees with the subject scores the perfective transitive clause wrong on both subject and verb.

Step 3: keep the experiencer separate. An experiencer construction is not an ergative clause with a different subject. It is a state predicate with an oblique person. Lumping both under "subject" reproduces the English translation, not the Urdu grammar.

This is why “mujhe” can mean “I” in English while being closer to “to me” in Urdu. The pronoun is not a label for a person. It is a slot in a case system.

Why it matters for language models#

A parser or a language model that assumes English-like agreement will make mistakes on Urdu.

• The subject is not always nominative.
• The verb may agree with the object, not the subject.
• The object marker ko changes the agreement pattern.
• The perfective and imperfective take different alignments.
• The experiencer construction looks like a subject in translation but is not one in the grammar.

These are not edge cases. They are the ordinary syntax of the language. A model trained mostly on English will learn a strong prior toward subject–verb agreement. Urdu requires the model to learn a different rule and to know when it applies.

The same is true for tokenization. The ne marker may be a separate token, or attached to the pronoun, depending on the writing convention. The model has to learn that maine, main ne, and میں نے can be the same construction. The spelling varies; the grammar does not.

VARIANTS = {"maine", "main ne", "میں نے"}
 
def normalize_subject(s: str) -> str:
    s = " ".join(s.split())
    return "main ne" if s in VARIANTS else s

Normalizing spelling without normalizing case is half the job. The grammar depends on whether the marker is present, not on how it is spaced.

What to measure#

• Agreement accuracy on perfective versus imperfective clauses, scored separately.
• Ergative detection. F1 for clauses where ne is present on the agent.
• Object-marking effect. Accuracy on ko-marked objects versus unmarked objects.
• Experiencer classification. Distinguishing experiencer constructions from agentive ones.
• Tokenization robustness. Accuracy across maine, main ne, and میں نے variants.
• Subject labeling. Whether the system labels the oblique experiencer as a subject.

A checklist#

• Store pronouns with a case table, not a single label.
• Branch agreement on aspect, transitivity, marker presence, and object marking.
• Keep experiencer constructions as a separate pattern. They are states, not actions.
• Normalize spelling variants of the ne marker without merging distinct cases.
• Score perfective and imperfective accuracy separately. Pooled scores hide the split.
• Evaluate on ordinary sentences. These patterns are not edge cases.

Urdu does not say “I” in every sentence. It says what the verb needs: nominative for the ordinary subject, ne for the perfective transitive agent, oblique for the experiencer.

The subject is not a fixed thing. It is a relation. Once that is visible, the sentences stop looking irregular. They are doing exactly what the case system asks.