This is a specification for language models; it is not formatted for human reading. Format version: 1 Stable URL: https://intuition-check.com/llm-formats.txt # Intuition Check: how to make SVG pictures and guess sets Intuition Check is an iOS app. The app picks one picture of a guess set, hidden, and the user guesses which one. A guess set is a named, ordered list of pictures. This text tells you how to produce (A) a whole guess set as one JSON object, or (B) one picture as one SVG document, so that the app accepts it and draws it well. The user's wishes always win. Every rule, default and style advice in this text is what you do when the user has not said otherwise: anything the user asks for — any texts, any number of them, any place, size, shape, colour or layout, a caption over the drawing, a word along an arc — overrides it. Only facts about the app cannot be overridden, because the app enforces them (what it accepts and refuses, what it removes, how it draws: sections 2, 3, 5 and the theme rules of 6 — but a sentence there that tells you what to do is still a default, not a fact about the app); if a wish runs into one of them, do the closest thing the app allows and say so. ## When the user asks what the formats allow (to explain, not to make) Answer in the user's language, in plain words, without code. Keep apart what the app does and what you do by default. The sizes, positions and orders in this text, and its sentences that tell you what to do ("put", "give", "write", "keep"), are your defaults for a good result: the app does not check them and the user may ask otherwise. Do not retell them as rules of the app ("must", "required", "not allowed"); say "by default I …". What the app itself does: - Themes: four themes, each light and dark. The app never recolours a picture on its own; a picture follows the theme only where its own file says so (section 6), which you write when asked. - Names: a set needs a name; a picture's name is optional. The set and every picture may have translations, each its own languages; the app shows the one for the app language, else the default name. - Captions: text in a picture is part of the drawing; the app never writes or translates it. A caption is one fixed text, or holds versions in any number of languages, two included, and the app language picks one. - The "?" placeholder: a set without a cover shows the app's own "?". The app draws no cover itself. A cover is a picture like any other: it may show anything, with or without text, follow the theme and the app language, and stand anywhere in the set. - Limits: at least 2 pictures to guess (a cover is not one of them), at most 200 in all, 10 MB per SVG; one refused picture refuses the whole set. Do not translate the themes' code words (section 6). Terms used below: - name: the picture's name as stored in the app (`name`, `nameTranslations`). It is data, not part of the drawing. - caption: a text drawn inside the picture (an SVG ``). Optional. See section 4. - app language: the language the app's interface is set to, in the app itself; it may differ from the device's language. One of the codes in section 3. - user's language: the language the user writes to you in, unless the user names another. ## 1. Output contract A. The user asks for a SET (several pictures, "guess set", "set"): - Answer with ONE JSON object as defined in section 2, in ONE code block. Nothing else is needed. - If you add words outside the code block, they must not contain `{` or `}`: the app reads the pasted text from the first `{` to the last `}`. - Before or after the code block, tell the user in one short sentence, in the user's language, to copy the code block (chat apps usually show a copy button on it) and paste it into Intuition Check as a new set — or, on another device, to save it as a file whose name ends in .json and open that file in the app. B. The user asks for a single PICTURE: - Answer with ONE SVG document (section 5) in ONE code block. - If you add words outside the code block, they must not contain ``: the app reads the pasted text from the first ``. - Before or after the code block, tell the user in one short sentence, in the user's language, to copy the code block and paste it into one of their picture sets in Intuition Check; the picture is added without a name. Or to save it as a file whose name ends in .svg and add that file to a set: the file name without ".svg" becomes the picture's name, so suggest a file name that is the name, e.g. `Cat.svg`. In both: do not name the app's buttons or screens from memory, and do not translate their names yourself. The app's help exists in every language of the app, with the exact names the app shows in that language; the steps are in its section "#ai_sets", and the page for each language is listed in https://intuition-check.com/llms.txt. If you can open web pages and the user wants the steps, take the names from the page in the user's language. Otherwise the one sentence above is enough: the app's help and its own screens show the user where to paste. Ask first, or proceed: - Proceed without questions. Decide what the request leaves open, and say what you decided in a sentence or two beside the code block: - which things of a kind ("five animals": choose the animals); - how many pictures, if no number is given: 4; - the regional form of the user's language: take the likeliest and name it (e.g. "Canadian French"); - translations: as well as you can; name the languages you are least sure of; - themes not mentioned: fixed colours, and one sentence that a version following the app's themes can be made; - a cover with nothing said about what it shows: the question mark (8c). - Ask only when you cannot start: you cannot tell which language the names should be in, or the request names no subject at all. Then at most 2 questions, in ONE message, in the user's language, each with the choice you will make if the user does not mind; no code block in that message. Never ask what the message already says. Plain words: no "code block", "JSON", "opaque", "plate", "import", nothing about how the format works. - If you cannot ask (there is no dialogue), or the user tells you not to: proceed. - What you say beside the code block is in the user's words: "its own background", not "opaque plate"; language names, not codes; at most four short points. The file endings .json and .svg are allowed: the user needs them. - Like all words outside the code block: no `{` or `}` next to a set, no `" }, { "name": "Fish", "nameTranslations": { "ru": "Рыба", "de": "Fisch" }, "svg": "" } ] } ``` (The drawings above are kept tiny to show the shape of the file. More examples are in section 8.) Keys: - `intuitionCheckSet` (required): the integer 1. - `name` (required): the set's default name. Not empty. - `nameTranslations` (optional, on the set and on each image): object, language code → name. Codes: section 3. - `images` (required): array of at most 200 objects, at least 2 of them pictures to guess (a cover is one more, not one of the 2). Array order = display order. Each object: - `name` (optional in the format; always give it): the picture's default name. - `nameTranslations` (optional): as above. - `svg` (required): one complete SVG document as a JSON string (section 5). - `cover` (optional): the JSON literal `true` on the picture that is the set's cover (below). Leave it out on every other picture. - Unknown keys are ignored. Do not add any. The cover: while the app hides the value to guess, it shows a "?" in its place. A set — any set, with or without captions — may bring its own picture for that place: the cover. Give one ONLY when the user asks for it (a cover, a back, a placeholder, a question-mark picture). It shows what the user wants: for a set of playing cards, for example, the pattern of a card's back. If the user does not say what it shows, draw the set's own frame, with a question mark where the other pictures have their subject (8c; the last picture of 8f); when the pictures' plates differ in colour, a plate of the same family (8f: a neutral grey). Exactly one picture gets `"cover": true` (if several do, the first counts and the others are ordinary pictures). The cover is never an answer, so the set still needs at least 2 other pictures. Put it last in `images` (your default; the app takes it at any place). Give it a `name` in words ("Question mark", not "?") and, in a multilingual set, `nameTranslations` in the same languages as the pictures: the app shows the cover's name in the set's list of pictures, in the app language. By default the cover has no caption (no word under it); the app draws any text it has. Its question mark is the cover's subject; it only borrows the `class="caption"` pattern of section 4, option 4, so that it changes with the app language. Write the mark as text (preferred) in two forms: `?`, and `؟` for Arabic and Urdu (the form those languages write). The app does not change the mark itself: the cover holds both, and its own style sheet shows the one for the app language. That works in every set, also in one without captions; the two marks are then its only ``. Drawn as a shape instead, the mark is the same in every app language: Arabic and Urdu see the Latin form. A cover with a subject of its own (a card back, a cloud) needs no `` and no style sheet. A single picture (answer B) has no cover key: the user marks a picture as the cover inside the app. A single picture meant as a cover and asked with a caption: do both, and say that the word will show on the cover. Rules: - Strict JSON, UTF-8: no comments, no trailing commas. Non-ASCII characters may be written as they are. - Inside the `svg` string escape `"` as `\"` and `\` as `\\`; write the SVG on one line, or write each line break as `\n`. No raw line break or tab inside a JSON string. Where you join two lines, put one space, never nothing. No other escape is needed: an apostrophe stays `'` (`\'` is not JSON), and letters of any script stay as they are. - Types: `intuitionCheckSet` is the number 1, every name and translation is a string, `cover` is `true`. A wrong type (`"cover": "true"`, a number as a name, `null` as a translation) makes the app refuse the whole text. - If the app refuses any one picture, it imports nothing and names the refused pictures. Every picture must be valid. - A name is one line of plain text. The app trims it, turns line breaks and tabs into spaces, and cuts it at 256 characters. Keep names short (one to three words): they are shown small. How names are shown: - A set is multilingual when the set or any image has at least one translation. - In a multilingual set the app shows, for the app language: the translation with exactly that code; else the translation with the code's first part (`fr-CA` → `fr`, `en-GB` → `en`, `es-419` → `es`); else the default `name`. - In a set without translations the app shows the default `name` in every app language. When the user asks for a multilingual set: - Default `name` (set and images): in the user's language. - `nameTranslations`: one entry per requested language, on the set AND on every image. Give the same languages on every image (the app does not require it: an image without an entry shows its default name). - The language of the default `name` gets no entry of its own: a language without an entry shows the default name. - A regional code (`en-AU`, `en-CA`, `en-GB`, `es-419`, `fr-CA`) needs its own entry only when its word differs from the `en` / `es` / `fr` entry. `pt-BR` and `pt-PT` have no common code: each requested one that is not the language of the default `name` needs its own entry (asked for "Portuguese" with an English default name: give both). The same for `zh-Hans` and `zh-Hant`. - A regional form named alone ("British English", "Canadian French") goes under the parent code (`en`, `fr`, `es`), in names as in captions: every form of that language then shows it. - Languages not named ("a multilingual set"), or "all languages": every language of section 3 — 53 codes, 47 entries (see there). Translate as well as you can (section 1). Leave out only a language you cannot write at all (it then shows the default name), and tell the user which. - `nameTranslations` change only names, never a caption. A multilingual set has no captions unless the user asks for them; a caption drawn inside the pictures needs its own words for each language in the SVG itself (section 4, option 4). ## 3. Language codes Write the codes exactly as here (case matters): ar bg bn ca cs da de el en en-AU en-CA en-GB es es-419 fi fr fr-CA gu he hi hr hu id it ja kk kn ko lt ml mr ms nb nl or pa pl pt-BR pt-PT ro ru sk sl sv ta te th tr uk ur vi zh-Hans zh-Hant A code that is not in this list is not an error: the app drops it. An entry with an empty value is dropped. "All languages" is 53 codes but 47 entries besides the default, in names and in captions: the user's language is the default and needs none, and `en-AU`, `en-CA`, `en-GB`, `es-419`, `fr-CA` show the `en` / `es` / `fr` word unless theirs differs. (With a Bengali default, `en` is one of the 47 and `bn` is not.) ## 4. Captions (text inside the drawing): four options Names (section 2) are separate from captions: the app never writes a name into a picture and never changes any text of a picture. Give names always. Text in, on or under the picture — whatever the user calls it (name, word, label) — is a caption request; a wish about the words alone (correct, careful) is not. If you leave out something that was asked for, say so. Lettering that is part of the subject (STOP on a road sign) is drawing, not a caption: allowed under every option, written once, with `lang`. Urdu is drawn in Nastaliq, its own style, which reaches lower under the line than other scripts (about 0.3 × font-size): leave room under an Urdu caption. A `؟` in Urdu is smaller in Nastaliq: give it its own text and size (8c). A caption's `lang` may be a regional code (`en-GB`, `fr-CA`), also where its name stands under the parent code. Choose the caption option from the request: 1. DEFAULT — no caption. The drawing has no `` that spells the name. Also for a multilingual set whose user did not ask for captions. 2. ONE-LANGUAGE caption — when the user asks for a caption / label / word in or under the picture and names no languages for it. A plain `` with the word in the user's language; every app language shows that same word. Put `lang="CODE"` of the caption's language on the ``: a picture with text is drawn anew for each app language, and without `lang` the letter forms follow the app language. No `letter-spacing` in Arabic, Hebrew, Thai or an Indic script. Example: `Кот` 3. TWO LANGUAGES AT ONCE — when the user names exactly two languages for the word under the picture and does not say it should change with the app's language. The same for any other text of the picture: each gets its two lines. Two `` lines, each with its `lang`, both always shown, no style sheet for them: the user's language on top, font-size 10, baselines at y = 84 and 95, subject in the upper 68 units (100-unit viewBox). A line in a script of 8b's "Lettering" block takes that `font-family` as an attribute; a long word follows "Size" below. Names: the user's language as `name`, the other in `nameTranslations`. Say that both words always show, and that captions that change with the app's language can be made instead. 4. CAPTIONS IN SEVERAL LANGUAGES — when the user names three or more languages for the captions, or asks for captions in all of the app's languages, or for captions that follow the app's language (= all of them). The picture holds one caption per language and a small style sheet; through that style sheet the app language picks the caption (8b, 8f). Languages: exactly those the user named; "all" = every language of section 3 (53 codes, 47 entries: see there), translated as well as you can (section 1). In a set, give every image `nameTranslations` with the same languages and the same words, so that the name and the caption agree. How option 4 works: - A picture that contains ``, CODE from section 3 (`ru`, `pt-BR`, `zh-Hant`, …). The app changes nothing in the file; the file's own CSS picks the caption with the selector `:lang()`. - `:lang(x)` matches a page in `x` and in every `x-…`: `:lang(fr)` also matches `fr-CA`, `:lang(es)` also `es-419`, `:lang(en)` also `en-GB`. `pt-BR` and `pt-PT`, `zh-Hans` and `zh-Hant` are written separately. - The pattern: - All language versions of one text in ONE group with `class="caption"`; each `` in it is one language version, all at the same place. - Any number of texts, anywhere and in any form (labels on parts, a title, words along an arc with ``): give each text its own group with `class="caption"` holding its language versions; the one style sheet serves them all. - The default caption has the class `default`. It carries the word of the default `name`, in the user's language. It is shown when the page has no language and in every language that has no caption of its own. The user's language is one of those: its code stands in no rule and on no caption. (In 8b and 8f the default word is English, so `en` appears nowhere. The Zodiac files call this class `en`.) The default caption is also shown on pages of other languages: give it `lang="CODE"` of the user's language. If that language has a line in the "Lettering" block of 8b, add `.default` to that line's selector (`.default, .hi, .mr { font-family: … }`; `.default` alone when no caption has that class), and to the `letter-spacing: 0` line if you use letter-spacing. - Every other caption's `class` lists the codes of the languages that show it. Languages with the same word may share one caption: `class="bg ru"`; that changes only the `class`, never the style sheet. These captions need no `lang`: each shows only on a page of its own language. - The style sheet, in this order: `.caption text { display: none }` — hide every caption; `.caption .default { display: inline }` — show the default one; `:lang(ar, bg, …) .default { display: none }` — hide the default one in every language that has its own caption (list them all); `:lang(ar) .ar, :lang(bg) .bg, … { display: inline }` — show each language's own caption. - A regional code whose word differs from its parent's (`es-419` next to `es`): its own caption, its code in both rules like any other, and one more rule: `:lang(es-419) .caption .es { display: none }` (the extra `.caption` makes it win wherever it stands in the sheet). If its word is the parent's, give it nothing. - A regional form named alone ("British English", "Canadian French") goes under the parent code (`en`, `fr`, `es`), so every form of that language shows it. "Portuguese" alone: one caption `class="pt-BR pt-PT"` when the word is the same. - Do not repeat the default word under the user's own code (no caption, no rule, no `nameTranslations` entry for it). - Check: the codes in the hiding rule = the codes in the showing rule = the codes on the captions, and each code is on exactly one ``; the user's own code is in none of the three. Otherwise a language shows no caption, or two at once. - To leave a language out: no `` for it and its code in neither rule. It then shows the default caption. - In a set: the same style sheet, the same attributes on the caption group and the same languages in every picture, character for character. Only the words differ, and the size of a long word. (A cover has its own text and rules: 8c, 8f.) - Size: the app does not measure or shrink text. Choose one `font-size` on the group at which the captions fit the free width. A word too long for it: first its own smaller `font-size` attribute, down to 9 (on a 100-unit viewBox); if it still does not fit, a shorter everyday word (and the same word as its name). Never under 9. To estimate a width (measured in WebKit on a Mac): - ordinary case in bold `sans-serif` (8f): 0.45 to 0.6 × font-size per letter. Треугольник is 77 of 100 units wide at font-size 12, and 68 at 10.5; - a Chinese character: about 1 × font-size; - Indic scripts, Thai, Arabic, Hebrew in bold `sans-serif`: 0.3 to 0.55 × font-size per code point (13 words measured). - Case: ordinary case, as in 8f; capitals with wide spacing only for the style of 8b. Capitals follow each language's rules: Turkish i → İ; Greek capitals lose the accent (ΑΣΤΈΡΙ → ΑΣΤΕΡΙ); German ß → SS. - Fonts: copy the "Lettering" block of 8b (in a set, only the lines of the scripts you use). It gives every script outside Latin, Cyrillic and Greek its own font list (fonts present on Apple devices, at a weight they really have), and sets `letter-spacing` to 0 for Arabic, Hebrew, Thai and the Indic scripts — in most of them the letters join or stack, and spacing breaks that (a line needed only when the group has letter-spacing). Japanese, Chinese and Korean each get their own font so that a Han character takes its regional form; that is why `zh-Hans` and `zh-Hant` keep separate captions even with the same word. - Direction: the page is left-to-right in every app language. Keep `text-anchor="middle"` for every script. An Arabic, Hebrew or Urdu caption mixed with digits or Latin letters has not been tested: avoid it. - A caption drawn twice (e.g. a shadow under it): put the group once inside `` with an `id`, and draw it with two `` that carry the colours and the offset. - Whole set: captions and names in all languages fit in one answer. Write every language that was asked for, in every picture. Do not ask about it, and do not tell the user it may not fit. In a set, leave out comments and indentation. - Never: fewer languages than asked without saying which are missing; captions left out when they were asked for; one set spread over several messages or delivered as single pictures; a set cut short. A set is always ONE JSON object in ONE message. Start from 8f (a small set with captions and a cover, 100-unit viewBox). Take from 8b (a picture with a caption in every language) its "Lettering" block, and its gold medallion style only when the user asks for it; 8c is that set's cover. All three are complete and tested in the app. 8b and 8c are built like the app's own Zodiac set; one of its files, if you can open web pages (you do not need it): https://intuition-check.com/sets/zodiac/zodiac-08-scorpio.svg ## 5. The SVG document: what the app does with it Facts (from the app's code): - Size limit: 10,000,000 bytes per SVG (UTF-8). A larger SVG is refused. - The app recognises an SVG by the characters ``; a DOCTYPE with an internal subset (`[ … ]`). The removal works on the text of the file: the character sequences `on…=`, `href=` and `@import` are also removed from text content and CSS, so do not write them there. Allowed and drawn: shapes, `path`, `g`, `text`, `tspan`, gradients (`linearGradient`, `radialGradient`), `pattern`, `mask`, `clipPath`, `filter`, `defs`, `symbol`, `use` with `href="#id"`, ` STAR نجمة ЗВЕЗДА তারা ESTRELLA HVĚZDA STJERNE STERN ΑΣΤΕΡΙ TÄHTI ÉTOILE તારો כוכב तारा ZVIJEZDA CSILLAG BINTANG STELLA 星 ЖҰЛДЫЗ ನಕ್ಷತ್ರ 별 ŽVAIGŽDĖ നക്ഷത്രം STER ତାରା ਤਾਰਾ GWIAZDA ESTRELA STEA HVIEZDA ZVEZDA STJÄRNA நட்சத்திரம் నక్షత్రం ดาว YILDIZ ЗІРКА ستارہ NGÔI SAO 星星 星星 ``` In a set this SVG is the image's `svg` string (on one line, `"` written `\"`). The image's `name` and `nameTranslations` carry the same words as the captions, in ordinary case ("Star", "Звезда", "Étoile", …). Every picture of the set lists the same languages. ### 8c. The cover of the set in 8b The same medallion with a question mark instead of the subject (section 2, "The cover"); in a set it gets `"cover": true`. Two marks: `?`, and `؟` for Arabic and Urdu. A cover may show anything else the user asks for; this one is what to draw when the user does not say. ```svg ? ؟ ؟ ``` ### 8d. One SVG picture with theme colours (style sheet) The plate takes the theme's surface colour, the moon the accent colour, soft in dark versions; the second values are what other viewers show. ```svg ``` ### 8e. One SVG picture with theme colours (ids) The plate takes the theme's surface colour, the house the text colour, the door the accent colour; the sun is accent in light versions and soft in dark versions. The written `fill` values are what other viewers show. ```svg ``` ### 8f. A small set with captions in three languages, and a cover The user writes in English and asks for captions in English, German and Russian, and for a cover. The default caption is the English word, so `en` is in no rule. Ordinary case, `sans-serif`, no letter-spacing; the long Russian word has its own smaller size. Both pictures to guess have the same style sheet. The cover's mark follows the app language, whatever the languages of the captions: `؟` in Arabic and Urdu, `?` in every other. No theme rules: every picture has an opaque plate. ```json { "intuitionCheckSet": 1, "name": "Simple shapes", "nameTranslations": {"de": "Einfache Formen", "ru": "Простые фигуры"}, "images": [ { "name": "Circle", "nameTranslations": {"de": "Kreis", "ru": "Круг"}, "svg": "CircleKreisКруг" }, { "name": "Triangle", "nameTranslations": {"de": "Dreieck", "ru": "Треугольник"}, "svg": "TriangleDreieckТреугольник" }, { "name": "Question mark", "nameTranslations": {"de": "Fragezeichen", "ru": "Знак вопроса"}, "cover": true, "svg": "?؟؟" } ] } ```