Why ChatGPT Gets Zi Wei Charts Wrong

What it does: (1) fixes one birth datum — March 15, 1990, 23:30, Taipei, male; (2) computes the complete Zi Wei chart for that datum with this site's deterministic charting engine and publishes it below as the reference; (3) organizes the recurring errors general-purpose language models (ChatGPT, Gemini, Claude and other chatbots) make when casting Zi Wei charts into four verifiable classes, with the mechanism behind each.

What it does not do: we will not paste a screenshot of "what ChatGPT said" as evidence. A single conversation is not reproducible — model version and sampling both shift the output, so arguing from a one-off transcript would be neither fair nor scientific. Instead, we state the errors as classes, each with a verification you can run yourself. The reproducible verification method is the argument.

The conclusion up front: casting a Zi Wei chart is a chain of table lookups where every step has exactly one correct answer; a language model is a probabilistic text generator with no built-in almanac and no star-placement tables. Asking it to cast a chart is like asking someone with an impressive memory — who never opens a book — to recite an entire almanac: the broad strokes are often right, and you cannot predict where the details are wrong.

The three tables below are this site's charting engine's complete output for the datum — an open-source Zi Wei engine (iztro) computing by table lookup under traditional San He school placement rules. The code is fixed, the same input always yields the same output, and an automated test pins these exact values: if any engine change invalidated the numbers on this page, the test would fail.

Two computation conventions, stated up front (they are also the legitimate sources of difference between tools): (1) the hour branch is determined from the local clock time you enter — no true-solar-time correction; (2) 23:00–23:59 is treated as the 子時 (Zi hour) of the same calendar day (no day advance). Before comparing any tool against this chart, confirm whether it shares these two conventions.

The first step of casting is converting the Gregorian birth date to the lunisolar calendar. For this datum, the correct answer: March 15, 1990 = the 19th day of the 2nd lunar month, 1990. A single table lookup — and the single most common place language models stumble: a lunar date off by a day or two, leap months misremembered (assigned to the wrong month), or inconsistent handling of the Zi-hour day boundary.

The mechanism is simple: the lunisolar calendar is astronomically defined — each month begins at an actual new moon, and solar terms are fixed by the Sun's ecliptic longitude. It cannot be derived by mental rules; it must be looked up. A computation engine ships the full conversion tables; a language model can only probabilistically "recall" almanac fragments scattered through its training data. To the model, "19th" and "20th" are equally fluent text — choosing the wrong one triggers no internal alarm.

Calendar errors are devastating because they sit at the very top of the computation chain: a wrong lunar date corrupts the day number used to place Zi Wei, and everything downstream inherits the error.

With the calendar right, the next stage is star placement — the most tightly-chained part of Zi Wei computation: the Life palace position comes from birth month and hour; the Five-Element bureau comes from the Life palace's stem-branch nayin (for this datum: Life palace 己卯, nayin "City Wall Earth", hence Earth-5 bureau); Zi Wei's palace comes from a table lookup on bureau plus lunar day (Earth-5 bureau, 19th day: Zi Wei in 辰); and all thirteen other major stars are derived from Zi Wei's position.

Note the structure: get the bureau wrong by one class and Zi Wei's position is wrong; put Zi Wei one palace off and all fourteen major stars shift wholesale — not "one wrong star" but a fully misplaced chart. Birth-year transformations are equally rigid: a 庚 (Geng) year is always Sun→祿, Wu Qu→權, Moon→科, Tian Tong→忌 — a fixed lookup where one memory slip corrupts everything, and where competing school mnemonics coexist in training data, making them easy for a model to cross-wire.

For a computation engine these rules are a few lines of table lookup. For a language model they are a multi-step chain where no step may be "approximately right" — precisely what probabilistic generation cannot guarantee.

This is the easiest class to verify yourself: give the same birth data to the same chatbot in two separate conversations, ask for a Zi Wei chart both times, then compare the Life palace, Five-Element bureau, and major-star positions item by item.

Casting is deterministic computation — same input, same output; the two results should match to the character. But language-model generation includes sampling randomness, so two "castings" can contradict each other on the lunar conversion, the bureau, or star positions. If the two runs disagree, at least one is wrong — and the model cannot tell you which.

This test is powerful because it requires zero metaphysics knowledge: you do not need to know how to cast a chart, only how to compare two tables.

A computation engine raises an explicit error on input it cannot handle. A language model behaves in the opposite way: certain or not, it generates a fully formatted, professionally worded, entirely plausible-looking chart — correct parts and wrong parts delivered in the same confident tone, with no "this may be wrong" markers attached.

This follows from the training objective: language models are optimized to produce fluent, helpful responses, not to refuse computational tasks. For the user it means errors carry no signal — a wrong chart and a right chart are visually indistinguishable. The only defense is checking against an external reference, which is exactly why this page's reference chart exists.

The four failure classes against engine behavior, in one table:

Three checks, from lightest to deepest — pick any one:

This article is not saying language models are useless — our own product uses AI heavily. The point is division of labor: casting is table computation, so it belongs to a deterministic engine; reading is a language task, so that is where AI comes in. That is exactly AskStar's architecture — the engine computes the chart first, the AI only translates the finished chart into plain language, and the computation layer never passes through a model. Details are public on the Methodology page.

So the one-line answer to "why does ChatGPT get Zi Wei charts wrong": because casting charts was never a language model's job. Use the right tool for each half — a lookup engine when you need a chart that is guaranteed correct, and AI when you want to understand it.