The user is asking me to create WAIS (Wechsler Adult Intelligence Scale) and WISC (Wechsler Intelligence Scale for Children) FSIQ (Full Scale IQ) test generators, each testing all 4 parts of FSIQ. Let me think about what this means: - WAIS is the Wechsler Adult Intelligence Scale (for adults, ages 16-90) - WISC is the Wechsler Intelligence Scale for Children (for children, ages 6-16) - FSIQ (Full Scale IQ) is composed of subtests The WAIS-IV and WISC-V have different structures. Let me recall: **WAIS-IV FSIQ** consists of: - Verbal Comprehension Index (VCI): Vocabulary, Similarities, Information - Perceptual Reasoning Index (PRI): Block Design, Matrix Reasoning, Visual Puzzles - Working Memory Index (WMI): Digit Span, Arithmetic, (Letter-Number Sequencing) - Processing Speed Index (PSI): Symbol Search, Coding, (Cancellation) Actually, WAIS-IV FSIQ uses 10 core subtests: 1. Vocabulary 2. Similarities 3. Information 4. Block Design 5. Matrix Reasoning 6. Visual Puzzles 7. Digit Span 8. Arithmetic 9. Symbol Search 10. Coding The 4 index scores: - Verbal Comprehension Index (VCI) - Perceptual Reasoning Index (PRI) - Working Memory Index (WMI) - Processing Speed Index (PSI) **WISC-V FSIQ** consists of: - Verbal Comprehension Index (VCI): Vocabulary, Similarities - Visual Spatial Index (VSI): Block Design, Visual Puzzles - Fluid Reasoning Index (FRI): Matrix Reasoning, Figure Weights - Working Memory Index (WMI): Digit Span, Picture Span - Processing Speed Index (PSI): Coding, Symbol Search Wait, WISC-V has 5 indices but FSIQ uses 7 subtests: 1. Vocabulary 2. Similarities 3. Block Design 4. Visual Puzzles... Actually WISC-V FSIQ uses: Similarities, Vocabulary, Block Design, Matrix Reasoning, Figure Weights, Digit Span, Coding, Symbol Search Hmm, the user says "all 4 parts of FSIQ" - this suggests they're thinking of the four indices: 1. Verbal Comprehension 2. Perceptual Reasoning (or Visual Spatial/Fluid Reasoning for WISC-V) 3. Working Memory 4. Processing Speed So I need to create test generators for both WAIS and WISC that cover these four domains. Now, important considerations: 1. The actual WAIS and WISC are copyrighted, proprietary tests. I can't reproduce actual test items, but I can create analogous/similar items that test similar cognitive domains. This is fine - creating new test items that measure similar constructs is legitimate. 2. The user wants "generators" - so they want programs/code that can generate test items. This suggests they want software (probably Python) that can randomly generate items for each subtest. 3. Practical considerations: Some subtests (Block Design, Visual Puzzles, Coding) are inherently visual/physical. A text-based generator has limitations. I could: - Use ASCII art or descriptions for visual items - Generate simple SVG/HTML output for visual items - Use text-based analogs Let me design this properly: **WAIS-IV Generator (Adult version) - 4 Indices:** 1. **Verbal Comprehension Index (VCI):** - Vocabulary: "What does [word] mean?" - generate from word lists by difficulty - Similarities: "In what way are [X] and [Y] alike?" - pairs database - Information: General knowledge questions - generate from database 2. **Perceptual Reasoning Index (PRI):** - Block Design: Hard to do in text... could generate SVG patterns - Matrix Reasoning: Generate visual matrices with SVG - Visual Puzzles: Generate spatial puzzles 3. **Working Memory Index (WMI):** - Digit Span: Forward, backward, sequencing - easy to generate - Arithmetic: Word problems - generate from templates - Letter-Number Sequencing: Generate random sequences 4. **Processing Speed Index (PSI):** - Coding: Symbol-digit matching - generate with SVG - Symbol Search: Visual search - generate with SVG **WISC-V Generator (Child version) - 4 Indices:** 1. **Verbal Comprehension:** - Vocabulary (with pictures in real test, but can do word definitions) - Similarities 2. **Visual Spatial / Fluid Reasoning:** - Block Design - Matrix Reasoning - Figure Weights (balance scale problems - these can be text/visual generated!) 3. **Working Memory:** - Digit Span - Picture Span (hard in text) - Letter-Number Sequencing 4. **Processing Speed:** - Coding - Symbol Search Let me think about the format. The user probably wants code. I should create a comprehensive Python program (or two programs) that: 1. Generate test items for each index 2. Have difficulty scaling (easy to hard) 3. Have scoring logic 4. Calculate index scores and FSIQ For scoring, I should implement a simplified version: - Raw scores → scaled scores (mean 10, SD 3) - Scaled scores → Index scores (mean 100, SD 15) - Index scores → FSIQ For a generated test, I can create my own norming logic - e.g., based on percentile conversions or simple z-score transformations. I should be transparent that this is a simulation/practice tool, not a clinical instrument. Let me design the code: ```python import random import json import math from dataclasses import dataclass ``` **Core structure:** - Item generation functions for each subtest - Difficulty levels (easy, medium, hard) - Scoring system - Report generation **Digit Span generator:** ```python def generate_digit_span(length): return [random.randint(0, 9) for _ in range(length)] ``` **Arithmetic generator (WAIS):** Classic WAIS arithmetic problems like: - "If you have 3 apples and buy 5 more..." - Mental math problems with increasing difficulty I can template these. **Vocabulary generator:** Need a word bank with difficulty levels and acceptable answer keywords. **Similarities generator:** "How are X and Y alike?" with expected abstract answers. **Information generator:** General knowledge questions with answer banks. **Matrix Reasoning:** This needs visual output. Options: - SVG generation (best) - Unicode/ASCII grids For a text response, I could generate SVG strings that can be saved to files. Or use simple text-based matrices with shapes described. **Block Design:** This really needs visuals. Could generate SVG patterns of red/white blocks. **Coding:** Digit-symbol pairs table + a row of digits to fill in symbols. Can be done with text/SVG. **Symbol Search:** Rows with target symbols and search groups. Text-based possible with unicode symbols. Given the complexity, maybe I should write a Python program that: 1. Generates a complete test battery 2. Outputs to console + optionally creates an HTML report with SVG visuals 3. Has an answer key and scoring system Let me think about length constraints. This is a BIG request - two full generators. I should probably: - Create one well-organized Python file for each, or one combined program with a shared framework - Make the code comprehensive but not infinitely long - Use text-based items where possible and SVG for visual items Actually, let me reconsider. The response would be extremely long if I write two complete programs. Let me think about what's most useful: Option A: One Python program with a `--scale wais` or `--scale wisc` flag, sharing infrastructure, with age-appropriate item pools for each. Option B: Two separate programs. I think Option A is cleaner and shorter. A single program with WAIS and WISC modes. Let me draft the architecture: ``` iq_test_generator/ ├── generator.py (main) ├── items/ (item banks) └── output/ (generated tests) ``` Or just one file. One file is easier to share in chat. **Program outline:** ```python #!/usr/bin/env python3 """WAIS-IV & WISC-V FSIQ Test Generator""" import random import argparse import json from dataclasses import dataclass, field # ============ ITEM BANKS ============ VOCAB_WAIS = { # difficulty: [(word, acceptable_keywords), ...] 1: ["apple", ...], ... } SIMILARITIES = [ {"items": ("dog", "cat"), "answer": "animals/pets", "difficulty": 1}, ... ] INFORMATION = [...] # knowledge questions # ============ GENERATORS ============ def gen_digit_span(min_len, max_len, direction): ... def gen_arithmetic(difficulty): ... # templated word problems def gen_matrix_reasoning(difficulty): # returns SVG or text description def gen_coding(): ... def gen_symbol_search(): ... # ============ SCORING ============ def raw_to_scaled(raw, max_raw, mean, sd): ... def compute_indices(...): ... def compute_fsiq(...): ... # ============ MAIN ============ def generate_test(scale, seed): ... ``` For scoring, I'll use a simplified psychometric model: - Each subtest raw score → scaled score (mean 10, SD 3) using a linear or percentile-based transform - Sum of relevant scaled scores → Index score (mean 100, SD 15) - Sum of all index scores → FSIQ I can approximate: scaled = 10 + 3 * z, where z = (raw - expected_mean)/sd. For generated tests without norms, I can define target performance distributions (e.g., assume average person gets ~60% correct with SD 15%). For Matrix Reasoning and other visual tests, I'll generate SVG. Let me think about how to make matrix reasoning generatable in text: A matrix reasoning item: 3x3 grid, first 8 cells filled following a rule, last cell empty, choose from 5 options. Rules can be: - Shape constant, count increases - Rotation - Color/shading pattern - Progression (size, count) I can represent shapes with SVG: circles, squares, triangles in grids. Generating SVG with simple embedded shapes is very doable. For Block Design: generate a 2x2 or 3x3 (or 4x4) grid of red/white halves... actual block designs are more complex (blocks are red/white halves). Simplified: red/white square grids to reproduce. Can generate SVG. For Visual Puzzles: given pieces, assemble into a shape. Hard in text. Could do simplified version with SVG. For Coding (Digit-Symbol): create a key mapping 9 digits to 9 symbols, then a row of digits where the person writes the symbol. Text-based with unicode symbols: ▲ ■ ● ◆ ★ ✚ ◐ ♥ ▼ or use letters/shapes. For Symbol Search: target symbol(s) at left, then a group of symbols — mark YES if target is in the group, NO if not. Text-based with unicode works. For Figure Weights (WISC-V): balance scales. "If 2 circles = 3 squares, and 1 circle + 1 square = 1 triangle..." Text/visual. Can be done with simple algebra and SVG scales. For Letter-Number Sequencing (WAIS supplementary, but could include): read letters+digits, repeat digits ascending then letters alphabetically. Easy to generate. For Picture Span (WISC): hard without images. Skip or use text-analog. For Cancellation (WAIS supplementary): scan a grid, cross out target shapes. Text grid works! Now, the user said "all 4 parts of FSIQ." For WAIS-IV, the four parts are VCI, PRI, WMI, PSI. For WISC-V, FSIQ technically has 5 domains (VCI, VSI, FRI, WMI, PSI), but if the user wants 4 parts, maybe they're thinking of the older WISC-IV structure (VCI, PRI, WMI, PSI). Hmm. WISC-IV FSIQ = VCI, PRI, WMI, PSI (four indices). WISC-V split PRI into VSI and FRI, making 5 indices. The user explicitly said "all 4 parts of FSIQ" for both. So: - WAIS-IV: VCI, PRI, WMI, PSI ✓ (four indices) - WISC-IV: VCI, PRI, WMI, PSI ✓ (four indices) Maybe I should implement WISC-IV structure (4 parts) as the user requested, or implement WISC-V and note the difference. I think I'll implement the 4-index structure for both (WISC-IV style), but mention WISC-V's 5-index structure as a note, and maybe include Fluid Reasoning items (Figure Weights) as optional. Actually, to honor "all 4 parts," I'll do 4 indices for both and add a note about WISC-V. Alternatively, I could offer WISC-V with the five indices but emphasize the four. Let me keep it simple: 4 indices each, matching the user's request, with a note. **Subtest selection per index (keeping it manageable):** WAIS-IV (core): - VCI: Similarities, Vocabulary, Information - PRI: Block Design, Matrix Reasoning, Visual Puzzles - WMI: Digit Span (f/b/seq), Arithmetic - PSI: Coding, Symbol Search WISC (child-adapted): - VCI: Similarities, Vocabulary (child-level words) - PRI: Block Design, Matrix Reasoning (+ Figure Weights for WISC-V flavor) - WMI: Digit Span, Letter-Number Sequencing (or Arithmetic) - PSI: Coding, Symbol Search (+ Cancellation) Both share a LOT of machinery — differences are mainly item difficulty/content and norming expectations. So one program with shared generators and scale-specific item banks makes sense. **Administering the test:** The generator could be interactive (administer in terminal) or output a test file + answer key. For a "generator," producing a test document (with visuals as SVG in an HTML file) plus an answer key/scoring sheet is probably the most useful. But interactivity is cool too — the test can be taken in the terminal. I'll make it do both: - `--mode file` → generates test + answer key (HTML with embedded SVG for visual items, answer key JSON/text) - `--mode interactive` → administers in terminal (examiner mode with instructions, timing for PSI/WMI) Hmm, that's a lot of code. Let me think about scope control. The response is already going to be very long. Let me aim for a complete, working, single-file program that: 1. Generates all subtests for both scales 2. Outputs an HTML test file with SVG visuals (this handles Block Design, Matrix Reasoning, Coding, Symbol Search, Figure Weights nicely) 3. Outputs an answer key 4. Includes scoring logic (raw → scaled → index → FSIQ) 5. Interactive terminal administration might be too much extra... but it makes it a real "test" rather than just printed sheets. Let me include a basic interactive mode for the auditory/verbal subtests and a self-administered HTML for visual ones? That complicates things. Simplest robust approach: generate a self-contained HTML test that can be taken interactively in a browser (with JS for scoring?), or a printable test + answer key. Actually, let me do: generate an HTML file containing: - Digit Span presented as... hmm, digit span requires auditory presentation ideally, or at least timed visual. In a printed test, you show digits for a few seconds then hide. In HTML, JS can flash them. This is getting big. Let me simplify to a well-structured program: 1. **Test generation**: produces structured JSON of all items (with SVG strings for visual items) 2. **HTML renderer**: builds a single self-contained HTML test (visual items inline as SVG; verbal items printed with space for answers; digit span as a "reveal/hide" card for self-testing or examiner use) 3. **Answer key**: printed separately + JSON 4. **Scoring script**: takes raw scores, computes scaled/index/FSIQ 5. Optionally: interactive terminal mode I need to be careful about response length. Two full generators... Let me estimate: a single program of ~400-600 lines could cover this. That's a long response but the user asked for "entire" generators, so length is justified. I should keep prose minimal and let the code speak. Let me now design the actual item generation logic in detail. --- ### ITEM GENERATION DETAILS **1. Vocabulary (WAIS & WISC)** - Word banks by difficulty tier (1-5) - WAIS words: easy (common) → hard (e.g., "abundant," "commodious," "perspicacious") - WISC words: easier (e.g., "ball," "brave," "silence") - Scoring: keyword matching against acceptable answer lists (0-2 points per word in real WAIS; I'll do 0/1/2 with keyword matching or self-report) For a generator with an answer key, keyword matching works: ```python VOCAB_BANK = { "easy": [("apple", ["fruit", "eat", "grow", "tree"]), ...], ... } ``` **2. Similarities** - Pairs with expected abstract answer keyword(s) - Real scoring: 0 (wrong/specific), 1 (concrete/partial), 2 (abstract) - Generator: pairs bank with tiered keywords: concrete (1 pt) and abstract (2 pts) - e.g., ("dog", "cat"): abstract "animals", "mammals", "pets"; concrete "four legs", "fur" - I can also procedurally generate pairs from category data: items from same category → pair them, answer = category. That's a genuine generator (unlimited items): ```python CATEGORIES = { "animals": ["dog", "cat", "horse", "lion", "cow", ...], "fruits": [...], "vehicles": [...], "instruments": [...], ... } ``` Sample two items from a category at difficulty-determined depth. **3. Information** - Knowledge question bank by difficulty (adult vs child banks) - Can't be fully procedurally generated (facts are facts), so a curated bank of ~40-60 items per scale is needed. I'll write a decent bank (10 per difficulty tier × 4-5 tiers). **4. Arithmetic (WAIS-WMI)** - Templated problems: real WAIS arithmetic is mental math word problems. - Procedural generation with templates: - Tier 1: simple addition/subtraction in context ("John has X apples, buys Y more, how many?") - Tier 2: multi-step, sharing/division ("X candies among Y children") - Tier 3: money, time, rates ("If a train travels at 60 km/h...") - Tier 4: percentages, ratios, work problems - Compute answers programmatically. This is a true generator. **5. Digit Span** - Forward: sequences of length 3-9 (WISC) or 3-10 (WAIS) - Backward: 2-8 - Sequencing (ascending): 3-9 - Fully procedural. Scoring: 2 trials per length, discontinue after both failed at a length; raw = total correct. - In the real test it's auditory; for self-use, print digits with a "cover/flip" instruction or HTML flash. I'll print them and instruct covering/flash cards. **6. Letter-Number Sequencing (optional add)** - Random letters+digits; answer: digits ascending then letters alphabetically. Fully procedural. **7. Block Design** - Real: reproduce 2D red/white designs with cubes. - Generator: random binary grids (2x2 for easy up to 4x4 or 3x3 complex... actually real blocks have diagonal splits; simplify to solid red/white cells for easy, add diagonal halves for hard). I'll generate a red/white grid SVG as the target design and note it should be reproduced with blocks (or drawn onto a grid). - For a paper test: "copy the design onto the grid" is a decent approximation, or provide multiple-choice? Real block design isn't multiple choice. Alternative for paper: provide 4 candidate completed grids where one matches... that changes the construct to visual matching. Hmm. For pragmatism, I'll generate the design and instruct copying onto a blank grid, scored by cell accuracy. It measures visuospatial construction — a fair analog. **8. Matrix Reasoning** - 3x3 (WAIS) or 2x2 up to 3x3 (WISC) matrices with progression rules: - Rule types: (a) shape constant + count progression (1,2,3 dots), (b) rotation, (c) size decrease, (d) color alternation, (e) addition/XOR combination of shapes across rows - Generate SVG: 3x3 grid; cells 8 filled per rule, cell 9 blank; 5 answer options SVGs (1 correct, 4 distractors: wrong count, wrong rotation, wrong shape, wrong color). - Fully procedural. This is the most code-heavy but very doable with simple SVG shapes (circle, square, triangle). Let me sketch the SVG helper: ```python def svg_cell(shape, color, size, count...): return f'' ``` Keep it simple: each cell contains n shapes of shape s at fixed positions. Matrix rule example: "count increases left→right: col j has j+1 shapes; rows alternate shape." Answer = 3 shapes of shape-of-row-3. Distractors: 2 shapes, 4 shapes, wrong shape, wrong color. Multiple rule templates: - R1: count progression (n = col index) with shape varying by row - R2: rotation: an arrow/triangle rotates 45° per cell - R3: color cycle across rows (R,G,B) - R4: size decrease left→right - R5: shape transformation: square→triangle→circle across row **9. Visual Puzzles (PRI, WAIS-IV)** - Real: assemble pieces into a target within a frame. - Text/SVG approximation: hard. Options: generate a simple tangram-like "which pieces combine to form the figure" multiple choice. Could do: show target shape subdivided into pieces; question: "select the 3 pieces (from 6) that combine to form the figure." Generating that procedurally is quite complex. - Simpler alternative: "which of these rotated views matches the figure?" or skip. Given effort budget, I might substitute with a "Pattern/Spatial" analog or include a simplified version: show a shape made of pieces; ask which piece completes it (like a jigsaw gap). Procedural: draw a rectangle grid with a missing chunk and 4 candidate chunks (one fits). That's a decent "piece fitting" item and easy with SVG. **10. Figure Weights (WISC-V FRI) — optional if doing WISC-V; the user wants 4 parts so WISC-IV style PRI; I could still include Figure Weights as part of PRI-equivalent "Fluid Reasoning" for WISC.** - Balance scale: procedural with algebra: choose weights (shapes with values), equations like circle + square = 4 triangles... Generate consistent system, ask what balances the last scale. Multiple choice. - This is very procedural: assign shape values, construct 2-3 scales, compute target, generate 4 numeric-ish options? Real figure weights options are shape configurations. Simplify: options are shapes with values implied; correct option = the shape combo equal in value to the missing side. Doable: e.g., Scale 1: ●● = ■■■ (2 circles = 3 squares); Scale 2: ■■ + ● = ▲? etc. **11. Coding (PSI)** - Key: digits 1-9 mapped to 9 unicode symbols. - Test: rows of random digits; participant writes symbol under each; 120 seconds; score = correct in time (or total if self-paced... real is 120s timed). - Text output with unicode: e.g., 1=▲, 2=■, ... Print rows: "3 7 1 2 9 ..." with blank underscores below. Answer key = symbol sequence. **12. Symbol Search (PSI)** - Each row: target group (1-2 symbols) at left | search group (5-7 symbols) at right; mark ✓ if any target appears, ✗ if not. - Generate ~40 rows; 120 seconds; score = correct − errors. Unicode symbols work great. Fully procedural. **13. Cancellation (supplementary PSI)** - Grid of random shapes; cross out all targets (e.g., all ● regardless of surrounding). Timed 45s. Text grid works. **14. Picture Span (WISC-V WMI)** — needs images; substitute with "Letter Span" or skip; I'll note substitution. Actually for WISC I'll use Digit Span + Letter-Number Sequencing for WMI to stay procedural. --- ### SCORING SYSTEM Real norms tables are copyrighted and can't be reproduced anyway; and a generator has its own items. I'll implement a transparent approximation: - Each subtest: define expected mean (μ) and SD (σ) for raw scores of a reference population (I'll state assumptions, e.g., "for an average adult, expected digit span total ≈ X"). Then scaled score = 10 + 3·z, clamped 1-19. - Index = 100 + 15·(mean of subtest z-scores), clamped ~40-160. Hmm, actually standard: sum scaled scores → index via norm table; I'll approximate with linear mapping of the sum around its expected mean/SD (sum of k scaled scores has mean 10k, SD 3·√k·ρ... composite reliability; simplify SD = 3·√k, ignoring inter-correlations, or use typical correlation ρ≈0.5: SD = 3·√(k + k(k-1)ρ)). Keep it simple and transparent: Index = 100 + 15·z_sum where z_sum uses mean 10k and SD 3·√k·√(1+(k-1)·0.55). Maybe simpler: z = mean of subtest z's; Index = 100 + 15·z. That's clean and defensible as an approximation. - FSIQ = 100 + 15·(mean of index z's) — or sum-based. Mean-of-z approach is clean. - Also add percentile conversion and classification labels (per common Wechsler descriptors: Very Superior ≥130, Superior 120-129, High Average 110-119, Average 90-109, Low Average 80-89, Borderline 70-79, Extremely Low <70). - Include discontinue rules and timing. I must add a disclaimer: this is an educational/practice tool, not a clinical instrument; real WAIS/WISC are copyrighted, professionally administered, and normed. My items are original analogs, not actual Wechsler items. That's an important note both ethically and for accuracy. Also note IQ estimates from self-administered tests are unreliable. --- ### PROGRAM STRUCTURE (single file, ~600-800 lines?) Given the two scales share most machinery, one file with `--scale wais|wisc` makes sense. But the user asked for "an entire WAIS and WISC FSIQ test generators" — maybe they'd accept one program that does both. That's more maintainable. I'll do one program with both scales, clearly sectioned. Actually, let me reconsider size. A full implementation with SVG matrix reasoning, block design, figure weights, coding, symbol search, scoring, HTML rendering, both banks... will be long. Let me aim for completeness but ruthless economy in code style. I'll write: 1. Brief intro + disclaimers 2. The code (single file, well-sectioned) 3. Usage instructions 4. Notes on the 4 indices per scale and scoring model Let me now write the actual code carefully. ```python #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ WAIS-IV & WISC-style FSIQ Test Generator Generates original (non-copyrighted) practice items analogous to the four FSIQ domains: Verbal Comprehension, Perceptual Reasoning, Working Memory, Processing Speed. Includes scoring -> Index scores -> FSIQ estimate. Usage: python iqgen.py --scale wais --seed 42 --out test_wais python iqgen.py --score answers_wais.json """ ``` **Item data structures:** ```python from dataclasses import dataclass, asdict, field import random, json, argparse, os, math SYMBOLS = ["▲","■","●","◆","★","✚","◐","♥","▼","♦","✜","▩"] ``` **Vocabulary banks:** WAIS vocabulary with tiers, keyword-based scoring: ```python WAIS_VOCAB = { 1: [("apple", "edible fruit grows on trees"), ("winter", "coldest season of the year"), ("bed", "furniture for sleeping")], 2: [("repair", "fix something broken"), ("consume", "eat or use up"), ("cautious", "careful, avoiding risk")], 3: [("audible", "able to be heard"), ("reluctant", "unwilling, hesitant"), ("taciturn", "habitually silent, uncommunicative"), ("fortuitous", "happening by chance, lucky")], 4: [("specious", "seemingly plausible but actually wrong"), ("penurious", "extremely poor; miserly"), ("sanctimonious", "making a show of moral superiority"), ("perfidious", "deceitful, betraying trust")], 5: [("perspicacious", "having keen insight"), ("vituperative", "bitter, abusive in criticism"), ("intransigence", "refusal to change one's views"), ("quotidian", "occurring every day; ordinary")], } ``` Each with keyword lists for auto-scoring: I'll provide `keys` list; 2 pts if any high-level key, 1 pt if any low-level key. Let me restructure: `(word, [(2, [keywords...]), (1, [keywords...])])`. Hmm, writing full keyword lists for ~40 words adds bulk. Compromise: give `abstract` keywords (2 pts) and `concrete/partial` keywords (1 pt) for a moderate bank (~24 words per scale). Fine. **Similarities** — procedural from category banks: ```python CATS = { "animals": {"abstract": ["animal", "living", "creature"], "concrete": ["four legs","fur","tail"], "items": ["dog","cat","horse","cow","lion","rabbit","mouse","elephant","tiger","sheep"]}, "instruments": [...], "fruits": ..., "vehicles": ..., "tools": ..., "clothing": ..., "furniture": ..., "sports": ..., "colors": ..., "fish", "birds", "insects"... } ``` Pair two items from one category. Difficulty: number of shared features/abstractness — I'll order categories by abstractness and control by tier. **Information** — curated banks. WAIS ~24 questions, WISC ~24 questions, tiered. These must be factual and unambiguous. Examples: - WISC Tier 1: "How many days are in a week?" (7); "What color is grass?" ... - WISC Tier 2: "In what season do leaves fall?" ... "How many legs does a spider have?" (8) - WISC Tier 3: "What is the capital of France?" ... - WISC Tier 4: "Which planet is closest to the sun?" ... - WAIS Tier: history/civics/science: "Who wrote Hamlet?" "What is the boiling point of water in Celsius?" "How many justices on the U.S. Supreme Court?" "What does H2O represent?" "Which war was fought between the North and South in the U.S.?" "Name the largest ocean." "What organ produces insulin?" etc. I need to be careful about US-centricity; I'll mix general questions. ~24 each is fine (6 per tier × 4 tiers). **Arithmetic** — templates by tier (WAIS harder, WISC easier): ```python def gen_arithmetic(tier, rng): if tier==1: a,b = rng.randint(3,9), rng.randint(2,9) return (f"Ali had {a} marbles and won {b} more. How many now?", a+b) tier2: division/sharing: total divisible by kids tier3: rate/time: speed problems, shopping totals with change tier4: percentages, average, ratio ``` Compute answer; distractors for MC? Real WAIS arithmetic is free-response (spoken). I'll do free response with answer key. Good. **Digit span** — trivial procedural. Structure: trials of each length L: for L in range(start,end+1): 2 sequences each. Report strings. Answer key = sequences. Structure for output: each trial prints digits; instructions: "Have the examinee... read aloud then hidden" — for self-test, "cover the row, memorize (1s per digit), then write." Since this is a generator + key, examiner instructions suffice. **Matrix reasoning (SVG)** — the meaty part. ```python def matrix_item(tier, rng): shapes = ["circle","square","triangle"] colors = ["#1a1a1a","#b22222",...] # keep simple: black, red, blue, green rules per tier: T1 (2x2 matrix, WISC): count progression OR color change T2: shape transformation across row T3 (3x3): rotation or count+shape (two rules) T4: XOR/union of col1+col2 = col3 (dots), or size progression + color cycle Build cell SVGs, blank target, 5 options: correct + distractors (mutate) ``` SVG helpers: ```python def shape_svg(shape, color, x, y, r): if shape=="circle": return f'' if shape=="square": return f'' if shape=="triangle": return polygon points ``` Cell render: count n shapes laid out in a row (n up to 4... need layout for counts 1-5 in a small cell: use positions). ```python POS = {1:[(25,25)], 2:[(17,25),(33,25)], 3:[(25,17),(17,33),(33,33)], 4: four corners, 5: corners+center} ``` Matrix SVG: 3x3 grid of 50px cells → total 160x160 plus border. Options rendered 5 mini-SVGs labeled A-E. The HTML will embed these inline. Also include a text fallback description? In terminal, print "[Visual item: see HTML]" for visual items — the console can't show it. Maybe also print a compact unicode representation for matrix items? E.g., rows like "●●● ▣ ▲" is insufficient for distractor discrimination. Console ASCII art of shapes is possible: characters ●■▲ with counts! Actually that could work for the count/shape rules: use unicode glyphs per shape: ```python GLYPH = {"circle":"●","square":"■","triangle":"▲"} # plus color? can't do color in console easily ``` Color adds difficulty; console can't show color. I could use different glyph sets per color: black ●, red ◉, blue ⬤? Not reliable. Alternative: use "outline" vs "filled": ○ vs ● for two colors; □ ■; △ ▲. That gives color/shading dimension in console! Nice — shading instead of color: filled vs outline. Then glyph+fill encodes shape+shade. Rotation can't be shown... skip rotation rules; use count, shape, fill, size(? size via glyph big? no). Keep rules: count progression, shape transformation, fill alternation, and combination rules. All console-friendly AND SVG-friendly (SVG uses fill=none/stroke for outline shapes). That's elegant: one generator function outputs both an SVG and a console-art representation. Distractors mutate count/shape/fill. **Block design (SVG + console)**: - Grid sizes by tier: 2x2, 3x3 (real: 2x2, 3x3, 4x4 in some). Simplify: red/white cells (+ diagonal-split cells at higher tiers? diagonal split is hard in console; use them in SVG only, or represent as two triangles chars). Keep solid cells; console uses "█" and "·". Task: copy design onto blank grid (paper). Score: correct cells? For self-administration scoring is manual vs key. Fine — answer key = the grid string. Actually for a more objective paper analog: multiple-choice "which completed grid matches the model, viewed as the whole design?" too easy. Copying is the real task; keep copying with scoring guide (1 pt per correct cell... but adjacency errors... fine, cell-accuracy scoring as approximation, noted). Alternatively "match under rotation" items: choose which of 4 grids is the model rotated. That's a decent perceptual analog, objectively scoreable, procedural! Let me include both: copying trials (core) — hmm, keep scope controlled: I'll do copy trials with grid scoring. Good enough, honest about approximation. **Visual puzzles**: I'll implement "which piece completes the pattern": SVG of a 4x4 patterned square with a missing quadrant + 4 options (one correct, others mirrored/rotated/wrong). Console: show the grid with "?" and options as mini-grids using glyphs — grids render okay in console with monospace. Rows of 4 chars × 4 lines per mini-grid; 5 grids per item is heavy but printable. Let me simplify to a 3x3 with center missing, options 2x2. Hmm. Let me reconsider: maybe represent visual puzzles as "matrix completion with patterned tiles" — essentially like a jigsaw. Simple version: a 4x4 binary pattern, one 2x2 quadrant missing, options are 2x2 blocks (one correct, 3 distractors: inverted, shifted, rotated). Console-printable as blocks of characters. This works and is procedural. **Figure weights (WISC PRI/fr**: balance items: - Assign shapes values; scales: (n1 A = n2 B), (n3 B = n4 C); final: (n5 C = ? options). Options: shape-count combos, one correct, distractors off by one. Console: use glyphs with equations like "●● = ■■■" and SVG scales... console text is fine: represent as scale drawings with text. In HTML, draw simple seesaw SVGs. I'll generate SVG scales (two pans) + console text form. Tiered: 2-scale to 3-scale systems, bigger numbers. For WAIS PRI, no figure weights (that's WISC-V FRI) — but since the user wants 4 parts and PRI for both, I'll use Block Design + Matrix + Visual Puzzles for WAIS; WISC: Block Design + Matrix + Figure Weights (WISC-V flavor) — hmm, but if WISC is "4 parts," its PRI equivalent = Visual Spatial + Fluid Reasoning merged. I'll present WISC subtests: Block Design, Matrix Reasoning, Figure Weights. WAIS: Block Design, Matrix Reasoning, Visual Puzzles. That differentiates adult vs child nicely and covers the construct. **WMI for WISC**: Digit Span (fwd/bwd/ascending) + Letter-Number Sequencing. **WMI for WAIS**: Digit Span (fwd/bwd/seq) + Arithmetic + (LNS optional). Real WAIS WMI core = Digit Span + Arithmetic. I'll do both + LNS as optional; keep core two to control length. Let me include LNS anyway since it's procedural and cheap (10 lines). Actually — length. Every extra subtest adds ~15-40 lines. Total budget: let me plan line counts: - Header/imports/disclaimer: 30 - Utility (rng, glyph, svg helpers): 60 - Vocabulary banks: 50 - Similarities banks: 35 - Information banks: 50 - Arithmetic templates: 40 - Digit span/LNS: 35 - Matrix reasoning: 90 - Block design: 40 - Visual puzzles: 45 - Figure weights: 45 - Coding: 30 - Symbol search: 30 - Cancellation: 20 - Test assembly (per scale): 60 - HTML rendering: 80 - Console rendering: 50 - Scoring (norms, indices, FSIQ, classification, report): 80 - CLI/main: 40 ≈ 870 lines. That's a very long response but "entire generators" justifies it. I could trim: drop Visual Puzzles and Cancellation and LNS? The user said "each testing all 4 parts of FSIQ" — minimum viable: 2 subtests per index = 8 subtests. I'll implement 2-3 per index, core focus, and keep code tight. Let me cut: WAIS PRI = Block Design + Matrix (+ Visual Puzzles if budget allows — I'll include it, it's neat). WISC adds Figure Weights. PSI = Coding + Symbol Search (both, cheap). WMI = Digit Span + Arithmetic (WAIS) / Digit Span + Letter-Number (WISC)... Actually let me give WISC Arithmetic too with easier numbers? WISC-V core WMI = Digit Span + Picture Span (can't do pictures). WISC-IV WMI = Digit Span + Letter-Number + Arithmetic. I'll do Digit Span + LNS for WISC, Digit Span + Arithmetic + LNS for WAIS. Fine. Scoring interface: after administration, examiner enters raw scores per subtest into a JSON (or interactive `--score` mode prompting). I'll support: `python iqgen.py score --answers answers.json` and interactive prompts. To keep it simpler: interactive scoring mode that asks for each raw score, then prints the report. Also auto-scoring for self-administered items? Too much. Examiner-enters-raw-scores is realistic (real WAIS scoring is examiner-based with manual judgment on verbal items). Norming model (transparent, stated): - For each subtest, define `expected_mean` and `sd` for the reference population (adults for WAIS, children for WISC — I'll pick plausible raw-score stats and clearly label them as calibration assumptions that users can edit). - z = (raw − mean)/sd → scaled = round(10 + 3z), clamp [1,19]. - Index z = mean of subtest z's (weighted equally) → Index = round(100 + 15·z), clamp [40,160]. - FSIQ z = mean of index z's → FSIQ = round(100 + 15·z), clamp [40,160]. - Percentile from normal CDF (use erf approximation via math.erf — available in Python's math! `math.erf` exists). percentile = 0.5*(1+erf(z/√2))*100. - Classification bands. Discontinue rules (simplified from the real approach): - Verbal subtests: tiered presentation; discontinue after N consecutive failures (e.g., 3)... For a generated practice test, simpler: administer fixed number per tier; score = correct count. I'll administer e.g., 4 items per tier × 4 tiers, discontinue optional. Keep fixed counts for scoring simplicity, mention discontinue rules in examiner notes. Timing rules: Coding 120s, Symbol Search 120s, Cancellation 45s, Block Design per-item time limits (30-120s), Arithmetic 30s/item... I'll include timers in instructions ("time yourself") and note raw-score adjustments. Now, HTML output: single self-contained file: - Cover: scale, seed, date, ID - Examiner instructions + timing per subtest - Items with inline SVGs, answer blanks (for print) - Answer key in separate file (answers_{seed}.json + .txt) and/or separate HTML page? I'll write `key.html` or text. JSON key is fine for scoring; also human-readable txt. Console output: prints the full test in text (with unicode art for visual items) — good for quick generation without opening HTML. Both by default? Console + files. I'll print a summary + write files; console full print optional via `--print`. Hmm, keep: always write HTML + key JSON + print console version too? That doubles rendering work. Decide: HTML is the primary artifact (visuals need it); console prints everything that's text-renderable and notes "see HTML for visual items." Actually let me make console fully renderable using the unicode tricks above (matrices, blocks, puzzles, weights all console-renderable; coding/symbol search/cancellation are natively text). Then HTML optional (`--html`). That's a nicer "generator" experience: works anywhere. Wait, but Block Design "copy the grid" works fine in console (█/· grid), answer key = grid. Visual puzzle grids: fine in console. Figure weights: text. Matrix: glyphs. Coding: symbols. So everything works in console! HTML adds polish (printable test). I'll implement console rendering as primary and a decent HTML export. Hmm, that's more code. Let me scope: implement console rendering fully + HTML export that reuses item data with SVG for visual subtests. I think I'll write HTML with SVG only for: Matrix, Block Design, Visual Puzzles, Figure Weights, Coding (key table), Symbol Search. It's a chunk of code but valuable. Actually, let me reconsider the response medium. Given chat constraints, an ~800-900 line code response is very long but the request is explicitly for "entire" generators for two scales — maximal scope. I'll write tight code, minimal comments, and a short intro + usage + scoring explanation. I'll go with a single combined program (one file) — it serves both scales via `--scale`, shares banks, and is genuinely better engineering; I'll note they could be split. Hmm — but the user asked for "an entire WAIS and WISC FSIQ test generators" (plural). Two files sharing a common core is cleaner conceptually but wasteful. A single script with `--scale wais|wisc` generating each is arguably "each generator." I'll do single file and say so. Hmm, wait. Let me reconsider whether HTML should even be included to control length. The core value: item generation + scoring. Console-only keeps it maybe 500-600 lines. HTML export adds ~150-250. Given the request's scale, I'll include a basic HTML export — it makes visual items actually usable/printable and looks professional. I'll keep HTML simple (no JS needed; static printable test + static key page in same file? Put key at END of HTML with page-break, or separate section). I'll put the key in the JSON and a separate key.html? Simpler: single HTML has "Examiner Key" section at the end after a page-break-before div. And answer-entry? No — scoring via terminal `--score` mode. Also discontinue/demarcation: mention in instructions. Let me also handle the "4 parts" framing clearly in intro: WAIS-IV-style battery (adults 16+): - VCI: Vocabulary, Similarities, Information - PRI: Block Design, Matrix Reasoning, Visual Puzzles - WMI: Digit Span (F/B/S), Arithmetic (+ Letter–Number Sequencing) - PSI: Coding, Symbol Search WISC-style battery (ages 6–16): - VCI: Vocabulary, Similarities - PRI (Visual Spatial/Fluid Reasoning): Block Design, Matrix Reasoning, Figure Weights - WMI: Digit Span (F/B/S), Letter–Number Sequencing - PSI: Coding, Symbol Search, Cancellation Now let me write the code for real. I'll be careful with correctness (this must run). ```python #!/usr/bin/env python3 """iqgen.py — WAIS/WISC-style FSIQ practice-test generator (original items). DISCLAIMER: Educational practice tool generating ORIGINAL items inspired by the cognitive domains of Wechsler tests. Not affiliated with Pearson. Not a clinical instrument; scores are estimates under stated calibration assumptions. """ import argparse, json, math, os, random, sys, datetime # ---------- constants ---------- GLYPH = {("circle",1):"●", ("circle",0):"○", ("square",1):"■", ("square",0):"□", ("triangle",1):"▲", ("triangle",0):"△"} FILL = {1: "black", 0: "white"} # svg style helper ``` For SVG, outline shapes need stroke. Let me write shape_svg(shape, filled, cx, cy, r): ```python def shape_svg(shape, filled, cx, cy, r, color="#1f2937"): style = f'fill="{color}" stroke="{color}" stroke-width="2"' if filled else f'fill="none" stroke="{color}" stroke-width="2"' if shape=="circle": return f'' if shape=="square": return f'' if shape=="triangle": pts=f"{cx},{cy-r} {cx-r},{cy+r} {cx+r},{cy+r}"; return f'' ``` Cell layout positions for n shapes (cell coords in a 50px cell, r≈8): ```python CELL_POS = {1:[(25,25)], 2:[(16,25),(34,25)], 3:[(25,15),(15,35),(35,35)], 4:[(15,15),(35,15),(15,35),(35,35)], 5:[(15,15),(35,15),(25,25),(15,35),(35,35)]} ``` Count max 5? Use up to 4 typically (col index 1..3 → 1..3 shapes; use up to 5 for some rules). Fine. Matrix item generator: ```python def gen_matrix(tier, rng): shapes = rng.sample(["circle","square","triangle"], 3) # rule chosen by tier if tier<=2: rule = rng.choice(["count","shape","fill"]) else: rule = rng.choice(["count_shape","fill_cycle","count_fill"]) build cells (row r, col c) per rule; target = cell(2,2); options: correct + 4 distractors mutated. ``` Rule semantics: - "count": same shape/fill all cells; count = c+1 → target has 3. - "shape": same count(1), fill; shape = shapes[c]... then rows identical — need row rule too. For 2-rule matrices: shape by column, fill by row: cell(r,c) = shape=shapes[c], fill=r%2. Target: shape=shapes[2], fill=0 (row 2 → 2%2=0). Let me define fill alternation by row parity: rows alternate filled/outline. Hmm, that's fine. - "count_shape": count=c+1, shape=shapes[r] (row determines shape). Target: 3 triangles of row-2 shape. - "fill_cycle": fill cycles 1,0,1 across columns per row with row-shift: cell fill = (r+c)%2. Target fill=(2+2)%2=0. - "count_fill": count=c+1, fill=1 if r==1 else 0... simpler: fill=(r%2), count=c+1. Distractors: mutate one attribute of correct: count±1 (bounded 1..4), wrong shape, wrong fill, or shuffle. Ensure uniqueness. Represent a cell as tuple (count, shape, filled). Cell rendering console: GLYPH repeated count times, e.g., "●●●"; empty cell = "▢?". Console matrix: 3 rows of cells joined with " | ". For 2x2 (tier1): similar with 2x2. I'll support both 2x2 (WISC easy) and 3x3 matrices. Block design generator: ```python def gen_block_design(tier, rng): size = {1:2, 2:3, 3:3, 4:4}[tier] p = {1:.5, 2:.5, 3:.4, 4:.35}[tier] # density grid = [[1 if rng.random()

scaled scores, four index scores, FSIQ, percentile, classification). DISCLAIMER: educational practice tool only — NOT a clinical or official assessment; norms here are transparent approximations you can recalibrate. """ ``` Then imports, constants. I'll now write all generator functions. Let me write with care about the details. Console rendering of visual items: Matrix console: ``` ● | ○○ | ▲▲▲ ■■■ | ●● | ▲ ? (options below) A) ○○○ B) ▲▲ C) ▲▲▲ D) ■■■ E) ▲▲▲▲ ``` Wait, fill as filled/outline: cell display: glyph repeated count. Empty target: "?" Cell to string: `GLYPH[(shape, filled)] * count`. If count==0 → "·"? Won't happen (counts 1..4). For 2x2 matrix: 2 cols. Rows: 2. Options: each option = mini string. Block design console: rows of "██·" etc. Use "█" and "·". Blank grid: "▢"? Use "·" for cells to fill; instruction: reproduce design. Show model, then blank grid with light dots. Actually "copy onto grid" in console: show model grid; the person copies onto paper. HTML: SVG model + empty grid with light gray lines. Key: model grid string. Visual puzzle console: 4x4 grid with missing 2x2 block replaced by "??" rows; options A-D 2x2 grids below. Figure weights console: ``` Scale 1: ●●● balances ■■ Scale 2: ■■■■ balances ▲▲▲ Scale 3: ▲▲▲ balances ? (1) ●●■ (2) ●▲ (3) ■■▲ (4) ●●●■■ ``` With SVG in HTML showing seesaws. Coding console: ``` Key: 1=▲ 2=■ 3=● 4=◆ 5=★ 6=✚ 7=◐ 8=♥ 9=▼ Fill in the symbol under each digit. Time: 120 seconds. 3 7 1 4 2 9 ... ▢ ▢ ▢ ▢ ▢ ▢ ... ``` Symbol search console: ``` Targets: ▲ ● Group: ■ ▲ ✚ ◆ ▼ → mark Y/N ``` Rows printed in two columns to save space. Instruction: mark ✓ or ✗. Key: Y/N. OK. HTML: I'll build a simple template with CSS for print, sections per subtest with instructions + timing boxes, items, and an answer key section at the end (page-break). SVG inline. Given the sheer amount, I'll write the HTML builder generically: each section has `title`, `instructions`, `items_html[]`, and I'll assemble. The generator returns items as dicts with both `console` and `html` (svg) representations where applicable — cleanest: each item dict: {"kind":..., "prompt": str, "key": ..., "svg": str(optional), "options": [...]}. Let me define item dicts: - Vocabulary: {"subtest":"Vocabulary","word":w,"tier":t} - Similarities: {"pair":(a,b),"tier":t} - Information: {"q":..., "a":[acceptable], "tier":t} - Arithmetic: {"q":..., "answer":int, "tier":t} - DigitSpan trial: {"kind":"fwd/bwd/seq","len":L,"digits":[...],"answer":[...]} - LNS trial: {"len":L,"mixed":[...],"answer":[...]} - Matrix: {"grid":[cell...], "target_cell":cell, "options":[cells...], "correct":idx, "console":str, "svg":str, "options_svg":[...]} — maybe generate svg strings at build time. - BlockDesign: {"size":n,"grid":[[...]],"limit_s":t,"console":..., "svg":...} - VisualPuzzle: {"grid","missing","options","correct", consoles, svgs} - FigureWeights: {"scales":[[lhs glyphs],[rhs glyphs]], "options":[combo strings],"correct":idx, svg} - Coding: {"key":{digit:sym},"rows":[[digits]],"answer_rows":[[syms]]} - SymbolSearch: {"rows":[{"targets":[...],"group":[...],"present":bool}]} Rendering functions console & html iterate these. Scoring: NORMS per scale per subtest: {"max":..., "mu":..., "sd":...}. Score mode: prompt per subtest (show max & definition), compute. Alright — also need FSIQ composition table: ```python BATTERY = { "wais": { "VCI": ["vocabulary","similarities","information"], "PRI": ["block_design","matrix_reasoning","visual_puzzles"], "WMI": ["digit_span","arithmetic"], "PSI": ["coding","symbol_search"]}, "wisc": { "VCI": ["vocabulary","similarities"], "PRI": ["block_design","matrix_reasoning","figure_weights"], "WMI": ["digit_span","letter_number"], "PSI": ["coding","symbol_search"]}} ``` Item counts per subtest (fixed for reproducibility from seed): - vocabulary: 20 (wais) / 16 (wisc), ordered tiers ascending - similarities: 12, tiers ascending - information: 16 (wais only? include wisc? WISC-V VCI core = Vocabulary+Similarities; Information is WAIS only. WISC-IV Information was VCI. For 4-part WISC include Information as optional? I'll include Information for WAIS core; WISC skip → but then WISC VCI has only 2 subtests vs 3. That's fine (real WISC-V VCI = 2 core). Actually let me include Information for WISC too as optional supplementary? Keep core per modern scale: WISC VCI = vocab+similarities. Hmm, but 12 items vocab? I said 16. VCI with 2 subtests is fine. - block_design: 6 (tiers 1,1,2,2,3,4 → sizes 2,2,3,3,3,4 for wais; wisc: sizes 2,2,2,3,3,4?) wisc easier: 2,2,2,2,3,3. fine - matrix_reasoning: 16, tiers 1..4 ×4; 2x2 for tier1-2 (wisc), wais tier1 maybe 2x2 as well? WAIS matrices all 3x3 in real test; I'll do wais tier1 3x3 easy rules; wisc tier1-2 2x2. - visual_puzzles: 10 (wais only), tiers - figure_weights: 12 (wisc only), tiers: 1-2: two-scale; 3-4: three-scale - digit_span: full fixed set (fwd 3-9, bwd 2-8, seq 3-9, 2 trials each) = 42 trials - arithmetic: 16 (wais) - letter_number: lengths 2-8 ×2 = 14 trials (wisc) - coding: 100 digits (wais), 80 (wisc) - symbol_search: 40 rows both (wisc 32?) keep 40/32... just 40 both. NORMS: WAIS: - vocabulary: max 40, mu 21, sd 6.5 - similarities: max 24, mu 12.5, sd 4 - information: max 16, mu 10.5, sd 2.8 - block_design: max 6, mu 3.6, sd 1.2 - matrix_reasoning: max 16, mu 10.0, sd 3.0 - visual_puzzles: max 10, mu 6.3, sd 1.8 - digit_span: max 42, mu 26, sd 6.5 - arithmetic: max 16, mu 8.5, sd 3.0 - coding: max 100, mu 56, sd 13 - symbol_search: max 40, mu 24, sd 8 WISC: - vocabulary: max 32, mu 16.5, sd 5.5 - similarities: max 24, mu 12.5, sd 4.2 - block_design: max 6, mu 3.8, sd 1.2 - matrix_reasoning: max 16, mu 10.5, sd 3.2 - figure_weights: max 12, mu 7.4, sd 2.4 - digit_span: max 42, mu 25, sd 6.8 - letter_number: max 14, mu 8.6, sd 2.6 - coding: max 80, mu 44, sd 11 - symbol_search: max 40, mu 23, sd 8 All flagged "adjustable calibration." Classification: ```python def classify(iq): if iq>=130: "Very Superior" elif 120-129: "Superior" elif 110-119: "High Average" elif 90-109: "Average" elif 80-89: "Low Average" elif 70-79: "Borderline" else: "Extremely Low" ``` Percentile via erf. Now — writing the code out. I must be very careful that it's syntactically valid and logically coherent. Let me write it fully in my head/on paper here, section by section, because I can't run it. I'll double-check tricky parts: SVG string building, rotations of 2x2 grids, LNS sorting, figure weights balance solving, option shuffling with correct index tracking, console alignment with East Asian wide chars (●, ■, ▲ are ambiguous width but generally render as single-width in most terminals... "▲●" typically single-width; some terminals double-width them (CJK contexts). Monospace alignment may be imperfect on some systems. I'll note to view in a wide/monospace font. Can't do much more.) Let me write the code: ```python import argparse, datetime, json, math, os, random, sys SHAPES = ["circle", "square", "triangle"] FILLED_GLYPH = {"circle": "●", "square": "■", "triangle": "▲"} OPEN_GLYPH = {"circle": "○", "square": "□", "triangle": "△"} def glyph(shape, filled): return FILLED_GLYPH[shape] if filled else OPEN_GLYPH[shape] def cell_text(cell): # cell = (count, shape, filled) if cell is None: return "?" count, shape, filled = cell return glyph(shape, filled) * count ``` Hmm — alignment in console: cells of varying width (counts 1..4). Pad with spaces to width 6. SVG: ```python def shape_svg(shape, filled, cx, cy, r): stroke = 'stroke="#222" stroke-width="2"' if filled: body = f'fill="#222" {stroke}' else: body = f'fill="#fff" {stroke}' if shape == "circle": return f'' if shape == "square": return f'' return f'' CELL_POS = {1: [(25,25)], 2: [(16,25),(34,25)], 3: [(25,16),(16,34),(34,34)], 4: [(16,16),(34,16),(16,34),(34,34)], 5: [(16,16),(34,16),(25,25),(16,34),(34,34)]} def cell_svg(cell, x0, y0, size=50): if cell is None: return f'?...' count, shape, filled = cell parts = [f''] r = 7 if count <= 3 else 6 for (px, py) in CELL_POS[count]: parts.append(shape_svg(shape, filled, x0+px, y0+py, r)) return "".join(parts) ``` For empty target cell add "?" text: `?`. Matrix generator: ```python def gen_matrix(tier, rng, easy_grid=False): n = 2 if easy_grid else 3 shapes = rng.sample(SHAPES, n) rule = rng.choice(["count", "shape_row", "count_fill", "shape_col_fill_row"]) # simpler: pick from rule set by tier ``` Let me define concrete rule functions producing cell(r,c): - "count": shape=shapes[0], filled=True (or rng fill fixed), count = c+1. (2x2: counts 1,2; target count 2) - "shape_col": count=1, filled=True, shape=shapes[c] (target = shapes[n-1]); but rows identical → rows redundant; acceptable for tier 1 but weak. Add row rule: filled = (r % 2 == 0). → "shape_col_fill_row": count=1, shape=shapes[c], filled=(r%2==0). - "count_shape": count=c+1, shape=shapes[r], filled=True. Target: (n, shapes[n-1], True). (3x3: 3 shapes) - "count_fill": count=c+1, filled=((r+c)%2==0), shape=shapes[0]. - "fill_row": count=2, shape=shapes[0], filled=(r%2==0)? Row rule only → columns redundant. Combine: "fill_cycle": filled=((r*1+c)%2==0), count=2? Hmm same as count_fill variant. Tier mapping: - tier1: "count" (2x2) - tier2: "shape_col_fill_row" (2x2 or 3x3) - tier3: "count_shape" (3x3) - tier4: "count_fill" (3x3) Add slight randomization: fill base randomized, shape order randomized. OK. Build grid cells for r,c in range(n): grid[r][c] = rule_cell(...); target = grid[n-1][n-1]; set grid[n-1][n-1] = None (unknown). Options: correct = target; distractors: - d1: mutate count ±1 (clamp 1..5, must differ) - d2: different shape - d3: flip fill - d4: mutate count +1 (other direction) or shape+count both Ensure all unique; sample 5 total (correct + 4) for 3x3, maybe 4 options (A-D) for 2x2. Real WAIS has 4-5 options. Use 5 for tier≥3, 4 for lower. ```python def _mutate(cell, rng, kind): count, shape, filled = cell if kind=="count": count = min(5, max(1, count + rng.choice([-1,1]))) elif kind=="shape": shape = rng.choice([s for s in SHAPES if s != shape]) elif kind=="fill": filled = not filled return (count, shape, filled) ``` Generate distractor set ensuring uniqueness vs correct and each other; if collision, mutate again. Console render matrix: rows: `" | ".join(cell_text(c).ljust(4) for c in row)` then blank line; options line: `A) ●● B) ...`. Actually for readability, options in a vertical list with letters. Fine: "A) ●●● B) ▲▲▲ C) ▲▲ D) ▲▲▲▲ E) ■■■" — join with 3 spaces. Hmm widths vary; fine. SVG for matrix: grid of cells: x0 = margin + c*50. Plus options as small grids at bottom, or options as separate SVGs in HTML? I'll render options inline as mini SVGs (each a single cell) labeled A) B) ... HTML item: table row of cells → one SVG: width = n*50+2*margin; include options as row of mini SVG cells with labels. Simplify: one SVG for the matrix (n×n cells + dashed target), and for options another SVG with the 5 option cells in a row labeled. Both easy with cell_svg. Block design: ```python def gen_block_design(rng, size, limit): while True: grid = [[1 if rng.random() < 0.45 else 0 for _ in range(size)] for _ in range(size)] if 0 < sum(map(sum, grid)) < size*size: # mixed break return {"size": size, "grid": grid, "limit_s": limit} ``` Console: rows: "".join("█" if v else "·" for v in row). Provide blank grid: "·"*size? For copying on paper, examiner instructions suffice; also HTML prints empty grid. Also for self-scoring: "compare your copy to the key." Wait, actually — a concern: with a printed blank grid, "copying" cells is nearly trivial (unlike physical blocks). The block construction skill is lost; it becomes a simple copy task. As a paper approximation, maybe rotate: show model; then answer grid options which is the model rotated 90°? Choose the option that matches the model exactly (options are rotated/reflected versions) — that's a "mental rotation/visual matching" task, objectively scoreable, procedural. That's a better paper analog! Block Design → "Block Rotation Matching": "Which option (A–D) shows the same design rotated?" Correct = same grid rotated 90°; distractors = reflections or single-cell changes? Reflections of the design would NOT be rotations, so a reflected version is a valid distractor (different design). Let me do: correct = rotate(grid, 90°) (or 180/270); distractors = flipH(grid) rotated, flipV, and rotate of a mutated grid (one cell flipped). Ensure uniqueness. Console: model grid printed, then 4 option grids. Good, scoreable MC. Name it "Block Design (rotation-match paper analog)" and note the real test uses physical blocks. Rotation of grid: `rot90 = [list(row) for row in zip(*grid[::-1])]` rotates... let me verify: zip(*grid[::-1]) gives 90° clockwise rotation. Yes: grid[::-1] reverses rows; zip(*...) transposes → 90° CW. flipH: [row[::-1] for row in grid]; flipV: grid[::-1]. Distractor construction: correct = rot90(grid, k for k in (1,2,3)); distractors: flipH(grid), flipV(rot90(grid, 2))? ensure != correct; mutated grid (flip one random cell) rotated. Need uniqueness checks vs correct and each other; retry loop. Console print: model + options as lettered grids. Widths: grids 2-4 chars wide; print each option on its own line: "A) ▓▓··\n ·▓·▓"? Better inline: options side by side separated by 6 spaces. Rows aligned across options requires careful padding — print each option as separate block lines: ``` Model A B C D ■■· ■··■? ... ``` Simplest: stack options vertically with labels: ``` A) ■■· ·■· B) ... ``` Verbose but clear. I'll stack vertically. For 4 options × 4 rows = 16 lines + model. OK. HTML: SVG grids side by side — easy and clean. Visual puzzles (piece fit): 4x4 binary pattern; remove 2x2 block; options: correct block + rotations/flips. Same machinery as block design rotation but at 2x2 block level! Reuse: generate 2x2 block from pattern; distractors = rot90(block), flips, inverted. Ensure correct not equal others. ```python def gen_visual_puzzle(rng, tier): size = 4 if tier <= 2 else 5 # 5x5? options block 2x2? keep 4x4 always, missing 2x2? For 5x5 missing... keep 4x4 & 2x2 for simplicity; higher tier: 5x5 with 2x2? Let me just do size 4, missing quadrant random. grid = random binary 4x4 balanced qr, qc = rng.choice([0,1]), rng.choice([0,1]) # block origin (top-left of missing 2x2) block = [[grid[qr+i][qc+j] ...]] set grid cells to None (display "?") options: correct=block; d1=rot90(block), d2=flipH(block), d3=invert(block) ensure distinct ``` Console: grid 4x4 with "??" in missing block; options lettered stacked 2x2 blocks. HTML SVG. Figure weights: ```python def gen_figure_weights(rng, tier): # values for attempt in range(100): vals = {} shapes = ["circle","square","triangle"] (+ maybe "diamond" for tier4? keep 3; tier4 adds a 4th? keep 3, bigger counts) v = rng.sample(range(2, 7), 3) va, vb, vc = v sol_ab = balance(va, vb); sol_bc = balance(vb, vc) if sol_ab and sol_bc and (va,vb,vc) distinct: break na, nb = sol_ab # na*va == nb*vb mb, mc = sol_bc # final: nc copies of C vs options nc = rng.randint(1, 3) T = nc * vc combos = [] for xa in range(0, 7): for xb in range(0,7): for xc in range(0,7): if xa*va+xb*vb+xc*vc == T and (xa,xb,xc) != (0,0,0): combos.append((xa,xb,xc)) rng.shuffle(combos) correct = combos[0] — prefer non-trivial: pick one with total glyphs between 2 and 4. distractors: value != T: generate by mutating correct counts, or combos for T±small. ``` Distractor generation: ```python def combo_value(c): return c[0]*va+c[1]*vb+c[2]*vc cands = [] for mut in single-step mutations (add/remove one glyph): if value != T and combo nonzero: cands.append(mut) ``` Also add combos with value T±? Ensure 4 unique options; fallback: extend search combos with value in (T-2..T+2, != T). Collect until 4. Shuffle; correct index recorded. Render combo: glyphs: "●●■" = 2 circles + 1 square. Order: all A's then B's then C's. Scales display: - Scale 1: "●●● ⚖ ■■" meaning 3 circles balance 2 squares. - Scale 2: "■■■■ ⚖ ▲▲▲" - Scale 3: "▲▲ ⚖ ?" → choose option. Wait: my construction: scale1: na copies of A vs nb copies of B; scale2: mb copies of B vs mc copies of C; scale3: nc copies of C vs [correct combo]. Tier: 3 scales for tier≥3? All tiers use 3 scales (the inferential chain); tier affects value sizes/counts. Tier1-2: use only 2 scales? If final scale involves C directly and we've established A:B and B:C, the chain is needed. Simplest: always 3 scales; difficulty via values/counts. OK — but tier1: maybe scale3 asks "?" on left side? Keep consistent: right side unknown. Also should the "answer" combos avoid using C glyphs (the unknown shape)? Using C in options is fine (its value is known from scale 2). OK. Check example: va=2, vb=3? balance(2,3): na in 1..6, nb in 1..6: 3*2=2*3 → na=3? balance returns first: na=1: 2 vs nb*3 → nb=2/3 no... loop na: na=2 → 4 vs nb*3 no; na=3 → 6 = nb*3 → nb=2 ✓ returns (3,2). Good: "3 circles = 2 squares". vb=3, vc=4? balance(3,4): nb=4 →12 = mc*4 → mc=3 ✓ "4 squares = 3 triangles". nc=2 → T=8. combos summing to 8: e.g., (4,0,0)=4 circles; (1,2,0)=1●+2■=2+6=8 ✓ nice. Options: (1,2,0) correct → "●■■". Distractors: mutations: (2,2,0)=10 ✓ distinct; (0,2,0)=6; (1,1,0)=5; (0,0,2)=8 — that equals T! Must exclude value==T. Good check in code. Max glyph counts ≤ 6 for display sanity; combos search range 0..6 fine. LNS: ```python def gen_lns(rng): trials = [] for L in range(2, 9): for _ in range(2): nd = rng.randint(1, max(1, L // 2)) # number of digits letters = rng.sample("BCDFGHJKLMNPRSTV", L - nd) # avoid vowels & ambiguous digits = [str(rng.randint(1,9)) for _ in range(nd)] seq = letters_digits_shuffled answer = sorted digits (ascending) + sorted letters ``` Note: real LNS: digits ascending then letters alphabetical. Store seq (list of strings) and answer list. Digit span: ```python def gen_digit_span(rng): trials = [] spans = {"forward": (3, 9), "backward": (2, 8), "sequencing": (3, 9)} for kind, (lo, hi) in spans.items(): for L in range(lo, hi+1): for _ in range(2): seq = [rng.randint(0, 9) for _ in range(L)] ans = {"forward": seq, "backward": seq[::-1], "sequencing": sorted(seq)}[kind] trials.append({"kind": kind, "len": L, "seq": seq, "answer": ans}) ``` No repeating rule (real test avoids immediate doubles?); not necessary. Avoid leading zeros? Real tests avoid 0 as first? Not strictly. Keep random; fine. Coding: ```python def gen_coding(rng, n_items): syms = rng.sample(["▲","■","●","◆","★","✚","◐","♥","▼","♦"], 9) key = {d: syms[d-1] for d in range(1, 10)} digits = [rng.randint(1, 9) for _ in range(n_items)] answer = [key[d] for d in digits] ``` Console render rows of 10 or 20 with underscores row below. HTML: table with digits and empty cells; key displayed. Symbol search: ```python def gen_symbol_search(rng, n_rows): pool = ["▲","■","●","◆","★","✚","◐","♥","▼","△","□","○","◇","☆"] rows = [] for _ in range(n_rows): targets = rng.sample(pool, rng.choice([1,2])) present = rng.random() < 0.5 if present: group = rng.sample(pool, rng.choice([4,5,6])); group[0] = rng.choice(targets) # ensure at least one target # ensure target actually in group: replace random element with a target else: group = rng.sample([p for p in pool if p not in targets], rng.choice([4,5,6])) # need len(pool) - len(targets) >= 6 → pool 14 - 2 = 12 ≥ 6 ok rows.append({"targets": targets, "group": group, "present": present}) ``` Wait if present, group = sample then set one element to a target — but that might duplicate an existing symbol. Use: `group = rng.sample(pool, k); idx = rng.randrange(k); group[idx] = rng.choice(targets)` — may create duplicate within group if that target already in group. To be safe: `group = [t for t in group if t not in targets]` then append target then pad with non-targets to size... Let me do clean: ```python k = rng.choice([4,5,6]) if present: non_targets = [p for p in pool if p not in targets] group = rng.sample(non_targets, k-1) + [rng.choice(targets)] rng.shuffle(group) else: group = rng.sample(non_targets, k) ``` Requires len(non_targets) ≥ k-1: 14-2=12 fine. Score: correct minus wrong; note in instructions. Vocabulary bank — writing now (compact): WAIS_VOCAB (tier, word, pts2 keys, pts1 keys): Tier 1: apple? For adults start slightly higher: - ("repair", ["fix","mend","restore"], ["broken","make work again"]) - ("cautious", ["careful","avoiding risk/danger"], ["slow","thinking first"]) - ("consume", ["use up","eat/drink"], ["buy","take in"]) - ("obedient", ["following rules/orders/commands"], ["does what told","good"]) Tier 2: - ("audible", ["able to be heard","loud enough to hear"], ["sound","hearable"]) - ("reluctant", ["unwilling","hesitant"], ["doesn't want to","slow"]) - ("elaborate", ["detailed","complex","intricate"], ["fancy","big"]) - ("fortify", ["strengthen","reinforce"], ["protect","build up"]) Tier 3: - ("taciturn", ["habitually silent/uncommunicative"], ["quiet","doesn't talk much"]) — hmm 1-pt "quiet" vs 2-pt "habitually silent" both similar; ok. - ("specious", ["seemingly right but actually false/wrong"], ["fake","misleading"]) - ("penurious", ["extremely poor","miserly"], ["stingy","cheap"]) - ("fortuitous", ["happening by chance","lucky"], ["unexpected","by accident"]) Tier 4: - ("perspicacious", ["keen insight/judgment","perceptive"], ["smart","observant"]) - ("sanctimonious", ["pretending moral superiority","hypocritically pious"], ["religious","judgmental"]) - ("vituperative", ["harsh/abusive in criticism"], ["mean","angry"]) - ("quotidian", ["daily","everyday/ordinary"], ["common","boring"]) 16 words WAIS (4/tier). WISC_VOCAB: T1: ("ball", ["toy/round object used in games/play"], ["round","bounces","play"])... scoring 0-2: for kids "round thing you play with" might be fine. Keywords: - ("ball", ["round object/toy","used in games","play"], ["round","throw","bounce"]) - ("book", ["pages bound together for reading"], ["read","pages","story"]) - ("shoe", ["clothing worn on the foot"], ["wear","foot","walk"]) - ("night", ["dark part of the day when sun is down","when we sleep"], ["dark","sleep","moon"]) T2: - ("brave", ["not afraid","showing courage"], ["strong","scary things"]) - ("repair"...) reuse: ("repair", ["fix","mend"], ["broken","glue"]) - ("enormous", ["very large/huge"], ["big","giant"]) - ("ancient", ["very old","from long ago"], ["old","history"]) T3: - ("conceal", ["hide","keep secret"], ["cover","not seen"]) - ("abundant", ["plentiful","existing in large amounts"], ["lots","many"]) - ("cautious", ["careful","avoiding danger"], ["careful","watch out"]) - ("resemble", ["look like/be similar to"], ["same","like family"]) T4: - ("audible", ["able to be heard"], ["hear","sound"]) - ("tranquil", ["calm","peaceful"], ["quiet","still"]) - ("demolish", ["destroy completely/tear down"], ["break","knock down"]) - ("sluggish", ["slow-moving/not active"], ["slow","lazy","tired"]) Good: 16 words WISC. Similarities categories (shared bank; WAIS adds abstract cats): ```python SIM_CATS = [ {"cat":"animals","abstract":["animal","living thing","mammal","creature"],"concrete":["legs","fur","tail","pets"],"items":["dog","cat","horse","cow","rabbit","lion","mouse","elephant","goat","sheep"]}, {"cat":"fruits","abstract":["fruit","food you eat","grown on plants"],"concrete":["sweet","skin","seeds"],"items":["apple","banana","orange","pear","grape","melon","plum","peach"]}, {"cat":"vehicles","abstract":["vehicle","transportation","carry people or goods"],"concrete":["wheels","engine","driver"],"items":["car","bus","bicycle","truck","train","airplane","boat","tram"]}, {"cat":"clothes","abstract":["clothing","things people wear","cover the body"],"concrete":["fabric","cloth","keep warm"],"items":["shirt","trousers","sweater","dress","skirt","sock","jacket","coat"]}, {"cat":"furniture","abstract":["furniture","found in a house","household items"],"concrete":["wood","legs","useful"],"items":["table","chair","sofa","bed","shelf","cupboard","desk","stool"]}, {"cat":"tools","abstract":["tools","used to do work or build things"],"concrete":["metal","handle","handyman"],"items":["hammer","saw","screwdriver","wrench","drill","chisel","pliers","axe"]}, {"cat":"musical instruments","abstract":["musical instruments","make music/sounds"],"concrete":["played","sound","noise"],"items":["guitar","piano","violin","drum","flute","cello","trumpet","harp"]}, {"cat":"sports","abstract":["sports","physical games/activities"],"concrete":["played","teams","exercise"],"items":["soccer","tennis","swimming","golf","basketball","gymnastics","boxing","rowing"]}, {"cat":"birds","abstract":["birds","animals that fly","have feathers"],"concrete":["wings","beak","eggs"],"items":["eagle","sparrow","owl","pigeon","crow","parrot","swan","duck"]}, {"cat":"emotions","abstract":["emotions","feelings","states of mind"],"concrete":["felt","mind","mood"],"items":["anger","joy","fear","sadness","envy","pride","shame","delight"]}, {"cat":"sciences/fields of study","abstract":["fields of study","subjects","sciences"],"concrete":["learned","school","knowledge"],"items":["physics","biology","chemistry","history","geography","economics","astronomy","psychology"]}, {"cat":"seasons","abstract":["seasons","times of year","periods of the year"],"concrete":["weather","months","climate"],"items":["summer","winter","autumn","spring"]}, ] ``` Difficulty: tier = index band; WISC uses bands 0-7 (concrete), WAIS uses later cats too. Sample 2 distinct items from cat. Tier mapping: for item i of 12: cat_idx = ordered list per scale: WISC picks cats [0..7] shuffled within; WAIS [2..11]. Actually simpler: tier = (cat position within scale's cat list)//(len/4). Meh — I'll define per scale: `sim_cats = SIM_CATS[4:] for WAIS, SIM_CATS[:8] for WISC`; tier for item j = j*4//len. Sample categories without replacement for variety. Information banks: WISC_INFO: T1: ("How many days are there in a week?", "seven"), ("What season comes after summer?", "autumn/fall"), ("How many legs does a spider have?", "eight"), ("What do bees make?", "honey") T2: ("How many months are in a year?", "twelve"), ("Which planet do we live on?", "earth"), ("What do plants need to make food (two things)?", "sun(light) and water"), ("What is the biggest ocean on Earth?", "pacific") T3: ("What is the capital of France?", "paris"), ("Which gas do people need to breathe to live?", "oxygen"), ("What is water made of (chemical formula)?", "h2o"), ("Who was the first person to walk on the Moon?", "neil armstrong") T4: ("Which planet is closest to the Sun?", "mercury"), ("What force pulls objects toward the Earth?", "gravity"), ("What is the hardest natural material?", "diamond"), ("In which country are the Great Pyramids?", "egypt") WAIS_INFO: T1: ("How many days are in a year (not leap year)?", "365"), ("What is the currency of Japan?", "yen"), ("How many players are on a soccer team on the field?", "eleven"), ("What instrument measures temperature?", "thermometer") T2: ("Who wrote the play 'Romeo and Juliet'?", "shakespeare"), ("What is the largest mammal?", "blue whale"), ("What is the capital of Australia?", "canberra"), ("Which human organ pumps blood?", "heart") T3: ("At what temperature does water boil at sea level (Celsius)?", "100"), ("What is the chemical symbol for gold?", "au"), ("In what year did World War II end?", "1945"), ("Who proposed the theory of relativity?", "einstein") T4: ("What does DNA stand for?", "deoxyribonucleic acid"), ("Which cells in blood fight infection?", "white blood cells"), ("Approximately how fast does light travel?", "300,000 km per second"), ("What is the study of earthquakes called?", "seismology") 16 each. But wait — WISC battery: Information excluded (modern WISC-V). So WISC_INFO unused... but maybe include Information as supplementary for WISC too? To reduce code paths, generate Info only for WAIS. Hmm, but I listed WISC VCI = vocab + similarities only. That leaves WISC VCI with 2 subtests; fine (matches WISC-V). Arithmetic templates (WAIS, tiers): ```python def gen_arithmetic(rng, tier): if tier == 1: a, b = rng.randint(5, 15), rng.randint(2, 9) if rng.random() < 0.5: return (f"A library had {a} books on a shelf and received {b} more. How many books are on the shelf now?", a + b) return (f"Maya had {a} stickers and gave away {b}. How many stickers does she have left?", a - b) if tier == 2: k, each = rng.randint(3, 6), rng.randint(3, 9) total = k * each return (f"{total} candies are shared equally among {k} children. How many does each child get?", each) # or multiplication variant if tier == 3: v = rng.choice([40, 50, 60, 80]); t = rng.choice([2, 3]) return (f"A car travels at a steady {v} km per hour. How far does it go in {t} hours?", v*t) # or change: price, paid if tier == 4: kind = rng.random() if kind < .5: p = rng.choice([20, 25, 50]); n = rng.choice([40, 60, 80, 120]) return (f"What is {p}% of {n}?", n*p//100) # average nums = [rng.randint(2, 20) for _ in range(3)] while sum(nums) % 3: nums[rng.randrange(3)] += 1 return (f"Sam's scores on three tests were {nums[0]}, {nums[1]}, and {nums[2]}. What is the average?", sum(nums)//3) ``` Tier2 also halves: "If you cut 10 apples in half, how many pieces?" fine skip. WISC arithmetic? WISC WMI = digit span + LNS; no arithmetic needed. OK. Coding for WISC vs WAIS: same machinery, different item counts (80 vs 100) — WISC-V coding has animal... paper version fine with same digit-symbol format but maybe fewer. OK. Now the assembly function: ```python def generate(scale, seed, examinee=""): rng = random.Random(seed) cfg = BATTERY[scale] test = {"scale": scale, "seed": seed, "examinee": examinee, "date": ..., "subtests": {}} # VCI test["subtests"]["vocabulary"] = {"items": [ ... words in tier order ...], "scoring": "0/1/2 per word (see key)"} ... ``` Representation choices: store subtests dict: key → {"items":[...], "instructions": "..."}. Console rendering: a big function `print_test(test)` that walks battery order and prints each subtest with numbered items, using item renderers. HTML builder `render_html(test)` similar with SVG. Given length constraints, let me consider trimming HTML? The console version renders everything textually. HTML is valuable for printing & visuals. I'll include a modest HTML builder. Total code maybe ~700 lines. Long response but acceptable for this request. Actually, let me reconsider: maybe make HTML optional but included. Yes. Scoring mode: ```python def run_scorer(scale): norms = NORMS[scale] raws = {} for sub, spec in norms.items(): prompt = f"Raw score for {label} (max {spec['max']}, typical mean {spec['mu']}): " val = input() → float/int; validate 0..max # compute report lines; write report JSON. ``` Index computation: ```python def z_of(raw, spec): (raw - mu)/sd for idx_name, subs in BATTERY[scale].items(): zs = [z_of(raws[s], NORMS[scale][s]) for s in subs] z_idx = mean(zs) index = round(100 + 15*z_idx) clamp fsiq_z = mean(index zs); fsiq = round(100 + 15*fsiq_z) ``` Also scaled scores per subtest: 10+3z rounded clamped 1..19 (display like real profile). Percentile: `def pct(z): return round(100*0.5*(1+math.erf(z/math.sqrt(2))), 1)`. Classification function as above. Report print: table: subtest | raw | scaled; indices; FSIQ; percentile; classification; disclaimer. Key JSON: everything with answers: vocab keys, similarities expected, info answers, arithmetic answers, digit sequences+answers, LNS answers, matrices correct letters, block grids, puzzle correct, weights correct, coding answer rows, symbol search Y/N. Also norms config. Filenames: f"{scale}_test_seed{seed}.html", f"{scale}_key_seed{seed}.json". Console print: full test text; visual items in unicode. Also print "Answers: see key file". Now, code for HTML: minimal CSS, sections h2, items in ordered lists, SVG blocks inline. For matrix items: `

Options: ...

` with options as mini SVG cells labeled A..E; participant circles answer or writes letter in blank: `Answer: ____`. Let me make sure SVG string for a matrix: ```python def matrix_svg(grid, target_pos): n = len(grid); size = 50 parts = [f'") return "".join(parts) ``` Wait — grid stores None at target already; so cell None → empty dashed cell with "?" text. Simplify: cell_svg handles None. Options SVG: `` per row. Symbol search HTML: rows table: targets | group | checkbox Y/N. OK writing final code. Also include `--items` overrides? No, keep CLI minimal: scale, seed, name, --html, score mode. One more consideration — timing/examiner instructions per subtest (include in output): - Vocabulary: read word aloud (or self: read), define; 30s each; score 0/1/2 with key. - Similarities: "How are X and Y alike?"; 30s; 0/1/2. - Information: 30s; 0/1. - Arithmetic: read aloud (self: read silently), no paper, 30s? real WAIS arithmetic allows some items with time bonus; simplify 45s. - Digit span: digits at 1/sec; forward/backward/sequencing rules; discontinue after failing both trials of same length (note in instructions). - LNS: read at 1/sec; repeat digits ascending then letters alphabetical. - Block design (rotation-match): 30-60s per item. - Matrix: untimed-ish 30s. - Visual puzzle: 30s. - Figure weights: 30s. - Coding: 120s total; score = correct. - Symbol search: 120s; score = correct − errors. Raw score definitions printed in key/scoring section. Discontinue rules: verbal subtests: "stop after 4 consecutive zero scores" etc. Keep as instructions. Now the code. Let me also double check LNS letters sample: `rng.sample("BCDFGHJKLMNPRSTVWXYZ", L-nd)` — need enough letters: max L=8 → letters up to 8-1=7; string has ~20 letters fine. Digits as strings vs ints: store seq as strings for display join; answer digits sorted numerically: if stored as ints, sort ints then map str. I'll store ints and render with join. For vocabulary auto-scoring guide: key shows word, 2-pt keywords, 1-pt keywords. For similarities key: abstract/concrete keyword lists. Now write HTML template with instructions; sections ordered: VCI (vocab, sim, info), PRI, WMI, PSI. Use battery order list: ```python ORDER = {"wais": [("VCI","vocabulary"),("VCI","similarities"),("VCI","information"), ("PRI","block_design"),("PRI","matrix_reasoning"),("PRI","visual_puzzles"), ("WMI","digit_span"),("WMI","arithmetic"), ("PSI","coding"),("PSI","symbol_search")], "wisc": [("VCI","vocabulary"),("VCI","similarities"), ("PRI","block_design"),("PRI","matrix_reasoning"),("PRI","figure_weights"), ("WMI","digit_span"),("WMI","letter_number"), ("PSI","coding"),("PSI","symbol_search")]} ``` Subtest display names dict. Now, console rendering details per subtest: Vocabulary: ``` VOCABULARY (VCI) — "What does ___ mean?" Score 0/1/2. Stop after 4 consecutive 0s. 1. repair ______________________ 2. cautious ______________________ ``` Key: word → keywords. Similarities: ``` 1. dog — cat (How are they alike?) ``` Information: ``` 1. How many days...? ___ ``` Key: answers. Arithmetic: numbered questions; key answers. Digit span: group by kind: ``` FORWARD (repeat in the same order) — digits shown 1 second each; cover/ listen 1) 4 7 2 (len 3) 2) 9 1 3 5 (len 4) ... BACKWARD (repeat in reverse) ... SEQUENCING (repeat lowest → highest) ``` For self-administration honesty, the printed digits are visible — examiner must hide them; the instructions state examiner reads aloud. For solo use: "reveal, read for (len) seconds, cover." Key includes sequences with answers. Block design (rotation match): model grid then options: ``` Which option is the same design rotated (not flipped)? Model: ██· ·█· A) B) C) D) ■■· ·■■ ■■· ■·■ ·■· ■·· ·■· ■·· ``` Options side-by-side: each grid 2-4 wide; pad. Printing side by side requires same row count across options (all same size — yes, same size grids). So side-by-side works: build row strings per option and zip. Label row above: "A) B) C) D)" with spacing = grid width + 4. Let me implement generic `grids_side_by_side(grids, labels, pad=6)`. Visual puzzle: ``` Which 2×2 piece completes the picture? ■□■□ □■?? ■□?? □■■□ A) ■□ B) □■ C) ■■ D) □□ ■■ □■ □□ ■□ ``` Options side-by-side 2x2 blocks: two rows. Doable with same side-by-side helper. Matrix: ``` ●● | ●●● | ▲ ... Which completes the matrix? A) ▲▲▲ B) ●●● C) ▲▲ D) ▲▲▲▲ E) ■■■ ``` Target cell shows "?" (the None cell). Figure weights: ``` FIGURE WEIGHTS — pick the option that balances the last scale. Item 1: ●●● ⚖ ■■ (3 circles balance 2 squares) ■■■■ ⚖ ▲▲▲ ▲▲ ⚖ ? A) ●■■ B) ●●● C) ■▲ D) ●●■■ ``` Coding: ``` KEY: 1=▲ 2=■ 3=● 4=◆ 5=★ 6=✚ 7=◐ 8=♥ 9=▼ Time: 120 s. Write the matching symbol under each digit. Score = number correct. 7 3 9 1 ... (10 per row) ▢ ▢ ▢ ▢ ... ``` Use "＿" or "▢"? Use "_" for blanks? "▢" nice. Rows of 10 for console (WAIS 100 digits → 10 rows; WISC 80 → 8 rows). HTML rows of 20. Symbol search: ``` Mark ✓ if any target symbol appears in the group, ✗ if none. Time: 120 s. Targets | Group | ✓/✗ ▲ ● | ■ ▲ ✚ ◆ ▼ | ___ ``` Key: Y/N per row. Now scoring input list for score mode = subtest keys from ORDER. Also maybe an "auto-check" feature? Skip. Edge details: - JSON dump with ensure_ascii=False. - Seed default: random (use random.randint). Provide --seed. - Reproducibility: all randomness via rng. Mutations & uniqueness helpers: ```python def uniq_cells(base, mutators, rng, n_needed): ... ``` I'll write per-generator simple loops with `while` and set of seen. For matrix options: correct target cell; build distractor candidates by mutating; ensure != correct and unique; take 4 (or 3). ```python def gen_matrix(rng, tier, small): n = 2 if small else 3 shapes = rng.sample(SHAPES, 3) base_fill = rng.random() < 0.5 rule = ... def cell(r, c): if rule == "count": return (c + 1, shapes[0], base_fill) if rule == "shape_row_fill": # shape by col, fill alternates by row return (1, shapes[c % 3], base_fill if r % 2 == 0 else not base_fill) if rule == "count_shape": return (c + 1, shapes[r % 3], base_fill) if rule == "count_fill": return (c + 1, shapes[0], (r + c) % 2 == 0 if base_fill else (r + c) % 2 == 1) ``` Hmm "count_fill": fill = (r+c+ (0 if base_fill else 1)) % 2 == 0. Simplify: flip = 0 if base_fill else 1; filled = ((r + c + flip) % 2 == 0). Tier→(rule, small): - tier1: ("count", small=True) - tier2: ("shape_row_fill", small=True) — for 2x2: shape = shapes[c%3] → c∈{0,1} → 2 shapes used; fill alternates by row: r%2: row0 filled?, row1 opposite. Target (r=1,c=1): shape=shapes[1], fill= not base? (r%2==1 → not base). OK. - tier3: ("count_shape", small=False) - tier4: ("count_fill", small=False) For WISC: tiers 1-2 small, 3-4 3x3. WAIS: all 3x3? Tier1 3x3 with count rule is easy enough; but "count" on 3x3: counts 1,2,3 by column — fine. So small = (scale=="wisc" and tier<=2). Cell text padding: counts up to 3 glyphs; width pad to 5. Options count: 4 if small else 5. Target position: last cell (n-1,n-1). Distractor kinds: cycle through ["count","shape","fill","count"] ensuring uniqueness; if mutation equals target or previous, mutate again (loop with safety). Note: for rule "count", distractor with same count but different shape/fill; mutation covers. Also ensure distractor count within 1..4 (3x3) / 1..3 (2x2): clamp with retry: if count out of range, try opposite direction; if still out, use different mutation kind. ```python def matrix_distractors(target, rng, k, maxcount): out, seen = [], {target} kinds = ["count", "shape", "fill", "count2", "shape"] i = 0 while len(out) < k and i < 40: kind = kinds[len(out) % len(kinds)] c = mutate(target, rng, kind, maxcount) if c and c not in seen: seen.add(c); out.append(c) i += 1 # fallback: brute force distinct cells while len(out) < k: c = (rng.randint(1, maxcount), rng.choice(SHAPES), rng.random() < .5) if c not in seen: seen.add(c); out.append(c) return out ``` mutate: ```python def mutate(cell, rng, kind, maxcount): count, shape, filled = cell if kind == "count": d = rng.choice([-1, 1]) if 1 <= count + d <= maxcount: return (count + d, shape, filled) d = -d if 1 <= count + d <= maxcount: return (count + d, shape, filled) return None if kind == "shape": s = rng.choice([s for s in SHAPES if s != shape]); return (count, s, filled) if kind == "fill": return (count, shape, not filled) ``` kind "count2": opposite direction — handled by rng.choice anyway; drop "count2". Block design rotation item: ```python def gen_block_design(rng, size, tier): while True: grid = [[rng.randint(0, 1) for _ in range(size)] for _ in range(size)] vals = {v for row in grid for v in row} if len(vals) == 2 and 1 <= sum(map(sum, grid)) <= size * size - 1: break k = rng.choice([1, 2, 3]) correct = rot(grid, k) distract_cands = [flip_h(grid), flip_v(grid), rot(flip_h(grid), 1), rot(mutate_one(grid, rng), k)] options = [] seen = {tuple(map(tuple, correct))} for d in distract_cands: t = tuple(map(tuple, d)) if t not in seen: seen.add(t); options.append(d) while len(options) < 3: d = mutate_one(grid, rng); t = tuple(map(tuple, d)) if t not in seen: seen.add(t); options.append(d) opts = [correct] + options[:3] rng.shuffle(opts) return {"model": grid, "options": opts, "correct": letters[opts.index(correct)]} ``` rot(grid, k): rotate k times 90° CW: ```python def rot(g, k=1): out = [row[:] for row in g] for _ in range(k): out = [list(r) for r in zip(*out[::-1])] return out ``` flip_h = [row[::-1] for row in g]; flip_v = g[::-1]. mutate_one: copy; flip random cell. Wait — is flip of grid guaranteed different from any rotation? A symmetric grid could collide; seen-check handles. But also correct vs distractor could coincide for symmetric patterns; check correct in seen first — correct is added to seen; distractors skipped if equal. But careful: if flip_v(grid) == rot(grid,k) then distractor equals correct → skipped, more fallbacks. But also: could two distractors be equal → skipped; fallback mutate_one. But mutate_one(grid) might equal rotations of grid? seen check includes only correct; also add other options into seen as we go — yes, seen updated as options appended. Also fallback loop checks seen. Also should distractors be "plausible"? They're flips/single-cell changes — plausible. One more check: correct must differ from model? Correct is rotated model — if grid symmetric under that rotation (e.g., 180° rotational symmetric), correct == grid, making "which is rotated" ambiguous but still valid (the correct option literally matches the model; participant picks the identical one — still the right answer). Hmm, but then option "correct" equals model displayed — trivially identifiable! Avoid: ensure correct != model: if equal, re-pick k or regenerate. Add check: if tuple(rot(grid,k)) == tuple(grid): try other k values; if all symmetric, regenerate grid. Implement: choose k from shuffled [1,2,3], pick first where rot != grid; else regenerate. Grid display for model & options: filled "█" (1) vs "·" (0). Colors in HTML: black/white squares via grid_svg. Time limit per item: size2: 30s; size3: 45s; size4: 60s. Visual puzzle: ```python def gen_visual_puzzle(rng, tier): while True: g = [[rng.randint(0,1) for _ in range(4)] for _ in range(4)] if mixed: break qr, qc = rng.choice([0, 1]), rng.choice([0, 1]) block = [[g[qr+i][qc+j] for j in range(2)] for i in range(2)] display = [row[:] for row in g] for i in range(2): for j in range(2): display[qr+i][qc+j] = None cands = [rot(block,1), rot(block,2), rot(block,3), flip_h2(block), flip_v2(block), inv(block)] # flip_h2 = [row[::-1] for row in block], inv = 1-x options=[block]; seen={canon(block)} for d in cands: if canon(d) not in seen: seen.add(canon(d)); options.append(d) # options may exceed 4 → take first 3 extras correct = "A" baseline then shuffle ``` Take correct + up to 3 distractors; if fewer, mutate block fallback. Shuffle with letters. canon = tuple of tuples. But wait: rot90 of a 2x2 block == flip? rot90([a b; c d]) = [c a; d b]; flip_h = [b a; d c]; flip_v=[c d; a b]; inv flips bits. Some may coincide with original (symmetric blocks, e.g., all-same block: all rotations equal original → excluded by seen). If block is uniform (all 0/all 1) → all candidates equal block or inv → only inv differs → options insufficient → mutate? inv always differs (bits flipped) unless... uniform block inv = other uniform, differs ✓. But rot/f/inv of uniform: rot == block → excluded; inv only distractor → need 3 distractors → fallback: mutate_one(block) variants (single bit flips) — generate until 3 unique. Also possible: block with 2 diagonal... fine, fallback covers. But subtlety: distractor must not be a valid alternative completion — it's about matching the pattern; since pattern is random binary, "correct" completion is uniquely the block; any other 2x2 that happens to fit the surrounding pattern contextually... it's a random pattern; there's no "contextual fit" rule; the correct answer is defined as the removed piece. But a careful participant could argue the pattern isn't unique — random binary patterns have no rule, so the only defensible answer is matching... wait, actually — if the pattern is random, the participant can't deduce the missing piece except by... they saw the full pattern? No! They never see the full pattern — the piece was removed before showing. So how would they know?? Uh oh. Visual puzzles in WAIS: the target figure is fully shown and you select pieces that reconstruct it. My analog: show pattern with hole and ask which piece fits — but the piece must be inferable from the pattern's structure. A random binary pattern is NOT inferable — the answer is unknowable! Fix: make the pattern rule-based so the missing block is deducible. E.g., pattern = 2x2 tiling of a base motif (each 2x2 quadrant equals the motif): then missing quadrant = the motif = any visible quadrant. But then it's trivially "same as neighbor." Better: pattern with per-row/per-column rules: e.g., stripes/checkerboard variants, or the block = rotation of neighboring quadrant. Design a family of rule patterns: - "checker": g[i][j] = (i+j)%2 → missing block deducible ✓ distractors = flips of block (which for checker block [0 1;1 0]: flips equal itself! inv also equals flipped... block for checker at any quadrant = [[0,1],[1,0]] or [[1,0],[0,1]]; rotations of checker block = itself? rot90([0 1;1 0]) = [1 0;0 1] = inv, actually that's the "other phase". Hmm, distractors thin out. Alternative rule set (choose per item): 1. "row-shift pattern": each row is previous row shifted right by 1 (cyclic) — visually like diagonals. Missing block inferable from local rows (since row i block cols follow from same row outside cols? The block spans rows qr,qr+1 and cols qc,qc+1; within a row, pattern is periodic with period 4? Not necessarily deducible... row-shifted: row r = shift(row 0, r). Row 0 random → but visible columns outside block in same rows give partial info: for row qr, cols outside block: values at qc, qc+1 unknown — row-shift structure ties row r cols to row r-1 cols; if block is at rows (0,1), cols (2,3): row0 col2,3 unknown, row1 col2,3 = row0 col1,0 — known from row0 visible cols 0,1 ✓; row0 col2,3 = row3 (shift by 4 = full cycle? shift right by 1 each row: row1 col j = row0 col (j-1)). Row0 col2 = row? Row0 is base — unknowable! Unless base row itself follows a rule. Simpler: make the missing piece determined by LOCAL continuity rules — e.g., pattern is symmetric: left half mirrors right half (g[i][j] = g[i][3-j] or its inverse...). If mirror symmetry: block at right side = mirror of left side ✓ deducible! Block at left = mirror of right ✓. But blocks only at qr,qc ∈ {0,1} with size 2 — covers quadrants. If pattern has vertical mirror symmetry and block is right-side quadrant → answer = mirror of left quadrant. If block is left quadrant → mirror of right. Top/bottom mirror similarly. To make it robust: choose symmetry axis: vertical, horizontal, or both (or diagonal!). - Vertical mirror: g[i][j] = g[i][3-j]. Generate random left half; mirror. Missing block on right → its mirror is visible left; missing on left → mirror visible right ✓. Top/bottom quadrants both work since rows unconstrained? Vertical mirror determines each row independently — a block missing at rows (0,1), cols (2,3): its cells = mirror of cells at cols (1,0) rows (0,1) ✓ visible. Works for any quadrant ✓. - Horizontal mirror: similarly ✓. - Diagonal mirror: g[i][j]=g[j][i]: quadrant (0,0) missing → = transpose of quadrant (1,1)? g[0][1]=g[1][0]... block (0,0) cells (i,j∈{0,1}) = g[j][i] for j,i∈{0,1} = block (0,0) itself — NOT determined by other quadrant unless block spans the diagonal... skip diagonal. So use vertical or horizontal mirror. Difficulty: add for higher tiers: mirror + inversion (g[i][j] = 1-g[i][3-j]): still deducible ✓. And distractors: the un-inverted mirror, rotations, flips — plausible. Hmm, but mirror symmetry might make it too easy for tier 1-2 — fine, tiered: tier1: vertical plain; tier2: horizontal plain; tier3: vertical inverted; tier4: horizontal inverted. Deducible ✓. Actually also "both axes" (full 4-fold symmetry): simpler still. Keep the 4 variants above. Distractor pool for inverted variants: plain mirror (likely differs), rot90(block), flips, block itself? No—block itself IS correct; distractors must be wrong: any grid ≠ block. Pool: [mirror_plain, rot(block,1), rot(block,3), inv(block), flip_h(block), flip_v(block)] filter ≠ block, dedup, take 3. For plain variants: inv(block) is a great distractor, plus rotations/flips. Some may equal block (symmetric blocks) — filtered; fallback random-not-equal. Generation: base half random but require block ≠ at least 3 distinct distractors — retry if not enough (e.g., uniform block: inv works; rotations equal block → only inv → fallback randoms give 2 more ✓ any random 2x2 ≠ block qualifies as "wrong" — but must be *plausibly* wrong, randoms fine). OK this is workable. Console: show 4x4 with "?" in hole; options A-D as 2x2 mini-grids. Wait, one more consideration: with mirror symmetry, an examinee could game it by just mirroring the adjacent quadrant — that IS the intended deduction. Figure weights glyph mapping: A=circle ● filled? Use filled glyphs for weights: ● ■ ▲. In HTML SVG shapes filled. Fine. Now norms and score-mode raw definitions summary (printed to console for examiner): - vocabulary: sum 0-2 per word - similarities: sum 0-2 per pair - information: # correct - arithmetic: # correct - digit_span: # trials correct (each of 42) - letter_number: # trials correct (14) - block_design: # items correct (6) — plus note real test uses blocks & speed bonuses - matrix_reasoning: # correct (16) - visual_puzzles: # correct (10) - figure_weights: # correct (12) - coding: # correct within 120 s (100/80) - symbol_search: correct − incorrect (can be negative; floor at... real SS allows negative→ raw 0? allow negative, clamp in z anyway) — allow raw ≥ -(n). Score mode validates -n..n? Let me just validate ≥ -max and ≤ max... simpler: allow any int in [-max, max]. Let me now also double-check the digit span backward answer: seq[::-1] — yes reverse order as heard. Sequencing: sorted ascending. LNS answer: digits ascending then letters alphabetical: e.g., seq ["F", "3", "B", "7"] → answer "3 7 B F". ✓ Instructions text for LNS: "Repeat: digits first, lowest to highest, then letters in alphabetical order." Coding digits: 1-9 only (matches key). ✓ Now HTML skeleton: ```html ...

...

Generated practice test... NOT a clinical instrument...

... sections ...

Examiner Key

...

``` Key in HTML: nice-to-have; JSON key also saved. I'll include key section in HTML (for the examiner to print separately) — but answer blanks for MC items are letters; verbal items need keyword guides → include. Alright — the volume is significant. Let me finalize decisions to control size: - Include: console rendering (full), HTML export (full but terse), JSON key, interactive scorer. - Response format: brief intro, the code block, usage, scoring explanation, disclaimers, and a table of the battery. Keep prose tight. Let me also sanity-check `math.erf` — yes, in math since 3.2. Classification bands (Wechsler-like): ≥130 Very Superior; 120–129 Superior; 110–119 High Average; 90–109 Average; 80–89 Low Average; 70–79 Borderline; ≤69 Extremely Low. ✓ Percentile: from FSIQ z. Confidence interval: report ± (15/√4 * 1.96)? FSIQ SE ≈ 15*sqrt(1-r)... skip; provide simple ±5 note? I'll add "±" using SEM estimate: SEM = 15*sqrt(1-0.9)=4.7 ≈ 5; 95% CI ≈ ±9. Fine, one line. Score-mode flow: ```python def score_mode(args): scale = args.scale print header raws = {} for idx, subs in BATTERY[scale].items(): for s in subs: spec = NORMS[scale][s] while True: txt = input(f" {LABELS[s]} — raw score (0–{spec['max']}): ").strip() try: v = int(txt); assert -abs? ``` For symbol_search allow negative: validation: if s == "symbol_search": lo = -spec["max"] else 0. OK. Then compute per-subtest scaled, per-index z & score, FSIQ, percentile, classification, and print a profile table + write JSON report `report_{scale}.json`. CLI: ```python def main(): ap = argparse.ArgumentParser(...) ap.add_argument("command", choices=["gen","score"]) ap.add_argument("--scale", choices=["wais","wisc"], required=True) ap.add_argument("--seed", type=int, default=None) ap.add_argument("--name", default="") ap.add_argument("--out", default=".") args = ap.parse_args() ... ``` gen: seed = args.seed or random.randrange(1<<30). Generate, print console test, write key JSON, write HTML. Everything printed with `#`-headers and unicode. Let me also double check some potential bugs in planned code: 1. `rng.sample(SHAPES, 3)` — SHAPES has exactly 3 ✓. 2. Matrix "shape_row_fill" with n=2: shapes[c % 3] for c∈{0,1} ✓ uses shapes[0],[1]; target uses shapes[1] ✓. 3. 3x3 "count_shape": shapes[r%3] all 3 used; target = (3, shapes[2]) — 3 glyphs; maxcount=4 for distractors; distractor count-1=2 ✓ or +1=4 ✓ ok. 4. Console width: pad cells to width 4 (max 3 glyphs + spaces): `cell_text.ljust(4)`; join " | "? "●●● | " heavy; use two spaces + "|"? I'll join with " | "? simpler: `("|".join(...))` fine. 5. Block design side-by-side rendering: label line: "A)" + spaces. Implementation: ```python def grid_rows(g, dark="█", light="·", pad=2): return [dark.join? ``` Each row string: "".join("█" if v else "·" for v in row). For None (puzzle hole): "?". side-by-side: ```python def side_by_side(grids, labels, gap=6): widths = [len(labels[i]) + max(len(r) for r in rows_i) ...] ``` Simplest: for each option, prepend label to first row: e.g. rows[0] = f"{letter}) {rows[0]}" and pad others with 3 spaces " ". Then zip across options with gap spaces: ```python def grids_side_by_side(grids, letters, gap=8): blocks = [] for g, L in zip(grids, letters): rows = ["".join("█" if v == 1 else ("·" if v == 0 else "?") for v in r) for r in g] rows[0] = f"{L}) {rows[0]}" rows = [r if i == 0 else f" {r}" for i, r in enumerate(rows)] blocks.append(rows) out = [] for i in range(max(len(b) for b in blocks)): out.append(("", gap).join(b[i] if i < len(b) else " " * len(b[0]) for b in blocks).rstrip()) ``` Hmm "".join with gap: `gap.join(part or pad for each)`. Need pad width = len(block first row). Compute per block width. Fine, implement carefully. 6. HTML svg for block grids: ```python def grid_svg(g, cell=26): h = len(g); w = len(g[0]) s = [f'") ``` cell/2 → float x like "13.0" fine in SVG. Or compute ints: (c*cell + cell//2). OK. 7. Figure weights svg: ```python def weights_svg(scales): # scales: list of (left_glyphs, right_glyphs); last right = "?" rows = [] for (l, r) in scales: rows.append((l, r)) build svg: each scale row: horizontal beam line, two pans with glyph text above ends, fulcrum triangle center. ``` Simplify: each scale: ``; text left above beam (y=Y-8), right similarly; small triangle under center. Height per scale 70. Glyph strings via . Right "?" styled red. Good enough. Console for weights uses ⚖ or "vs": use " ⬌ "? Use "=" with balance wording: I'll print like: ``` ●●● balances ■■ ``` and last: "▲▲ balances ?". Options: "A) ●■■ B) ...". Clean. 8. Coding console: rows of 10: ```python for i in range(0, len(digits), 10): chunk = digits[i:i+10] print(" " + " ".join(str(d) for d in chunk)) print(" " + " ".join("▢" for _ in chunk)) ``` Hmm "▢" width issues minor. Also key row per chunk. HTML: rows of 20 in a table: digit cell + empty cell below → use nested: `......`. 9. Symbol search console: ``` 1. targets: ▲ ● group: ■ ◆ ✚ ▲ ▼ → □ ``` Key: "Y"/"N". HTML table rows with checkbox? Static blank cell fine. 10. Key JSON structure: {scale, seed, date, subtests: {name: {"answers": [...], "guide": ...}}, norms: NORMS[scale]}. 11. Vocabulary items generation: tiers 1..4, 4 words each (16) for WISC, and WAIS 4 tiers × 4 = 16 too (I said 20 earlier; keep 16 → max 32 pts). Update NORMS: WAIS vocab max 32, mu 17, sd 5.5. WISC max 32, mu 17.5, sd 5.5. Wait, I planned WAIS vocab 20 words — 16 is fine and lighter. 12. Similarities: 12 pairs; WAIS uses cats 4..11 (8 cats: animals? hmm SIM_CATS order: I'll order roughly concrete→abstract: animals, fruits, vehicles, clothes, furniture, tools, instruments, sports, birds, emotions, sciences, seasons. WISC cats = first 8; WAIS = last 8 (clothes..seasons)? WAIS also fine with animals etc. Let me define: WISC uses indices [0,1,2,4,6,7,8] concrete-ish; WAIS uses [0..11] with tier by position... simpler: both use all 12 cats; tier mapping = cat index // 3 (0-2→t1, 3-5→t2, 6-8→t3, 9-11→t4); WISC restricts tiers ≤ 2? For a children's battery use cats[:9] (tiers 1-3), WAIS uses cats[3:] (tiers 2-4)? Meh. Decide: - WISC: cats[0:8] → sample 12 pairs from these 8 cats (repeat cats allowed with different item pairs), tier = min(4, cat_tier + 1) where cat_tier = idx//2 (0-3→tiers1-4)? Overcomplicating. FINAL: tier_of_cat = index//3 + 1 (1..4). WISC samples pairs from cats with tier ≤ 3 (indices 0..8); WAIS samples from cats with tier ≥ 2 (indices 3..11). 12 pairs each, tiers spread by sampling proportional. Implementation: pool = [cats...] per scale; for each of 12 pairs: cat = pool[i % len(pool)] (cycles through, ensures spread), sample 2 items from cat.items (avoid same pair repeats by tracking used pairs). Tier recorded from cat. Good. 13. Information: 16 items (4/tier) WAIS only. 14. Number formatting: seed in filenames. Potential runtime pitfalls: shuffle of options with correct letter tracking: ```python opts = [correct] + distractors; rng.shuffle(opts); ans_idx = opts.index(correct); correct_letter = "ABCDE"[ans_idx] ``` `.index` on lists of tuples works (equality) ✓ for cells; for grids use canonical tuples. For figure weights combos are tuples ✓. For matrix options as cells (tuples) ✓. Block design options as lists of lists — `.index` compares by value ✓ (list equality). But ensure no accidental equality (seen-check prevents). Now — I also want the console test to include timing instructions and a total test overview. And a header: ``` ================================================================ WAIS-STYLE FSIQ PRACTICE BATTERY (generated, original items) Examinee: X Seed: 123 Date: ... Four domains: VCI | PRI | WMI | PSI ================================================================ ``` Section headers per index with description. Also print discontinue/timing per subtest. Keep instructions brief. Given the size, I'll write the code as compactly as reasonable while readable. Let me now also decide NORMS final values: WAIS: ``` vocabulary: max 32, mu 17.0, sd 5.5 similarities: max 24, mu 12.5, sd 4.0 information: max 16, mu 10.5, sd 2.8 block_design: max 6, mu 3.6, sd 1.2 matrix_reasoning: max 16, mu 10.0, sd 3.0 visual_puzzles: max 10, mu 6.3, sd 1.8 digit_span: max 42, mu 26.0, sd 6.5 arithmetic: max 16, mu 8.5, sd 3.0 coding: max 100, mu 56.0, sd 13.0 symbol_search: max 40, mu 24.0, sd 8.0 ``` WISC: ``` vocabulary: max 32, mu 17.5, sd 5.5 similarities: max 24, mu 13.0, sd 4.0 block_design: max 6, mu 3.8, sd 1.2 matrix_reasoning: max 16, mu 10.5, sd 3.2 figure_weights: max 12, mu 7.4, sd 2.4 digit_span: max 42, mu 25.0, sd 6.8 letter_number: max 14, mu 8.6, sd 2.6 coding: max 80, mu 44.0, sd 11.0 symbol_search: max 40, mu 23.0, sd 8.0 ``` These are stated as editable calibration. Item counts recap (both scales): - vocabulary: 16 words (4 per tier) - similarities: 12 - information (WAIS): 16 - block_design: 6 designs (sizes per scale) - WAIS sizes: [2,3,3,3,4,4]? tiers → sizes [2,2,3,3,4,4]? WAIS: [2,3,3,4,4,4]? Keep [2,2,3,3,3,4]? Hmm arbitrary: WAIS: [2,2,3,3,4,4]; WISC: [2,2,2,3,3,4]? WISC easier: [2,2,2,2,3,3]. OK. - matrix_reasoning: 16 (tiers 1-4 ×4) - visual_puzzles (WAIS): 10 (tiers cycling 1-4) - figure_weights (WISC): 12 (tiers 1-4 ×3) - digit_span: 42 trials - arithmetic (WAIS): 16 (4/tier) - letter_number (WISC): 14 trials - coding: WAIS 100 digits / WISC 80 - symbol_search: 40 rows (WISC 40 too? WISC maybe 32; use 40 both for simplicity — wait I earlier said WISC 32; just use 40 both) Coding WAIS 100 = 10 console rows; WISC 80 = 8 rows. Now writing the final code. I'll be methodical. Also add `if __name__ == "__main__": main()`. One more thing: the response should briefly explain what FSIQ's 4 parts are, and how scoring maps. Also crucial disclaimers: - Original items, not actual Wechsler items (those are copyrighted); this is a practice/training analog. - Not diagnostic; norms are approximations; self-administration undermines validity; digit span really should be auditory. Let me write everything now. I'll try to keep functions tight. Also: `letters = "ABCDE"`. Console labels: use section banners. Let me draft the complete code: ```python #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ iqgen.py — WAIS-style & WISC-style FSIQ practice-battery generator. Four FSIQ domains per scale (original items, NOT copyrighted Wechsler items): WAIS-style (16+): VCI: Vocabulary, Similarities, Information PRI: Block Design*, Matrix Reasoning, Visual Puzzles* WMI: Digit Span (fwd/bwd/seq), Arithmetic PSI: Coding, Symbol Search WISC-style (6–16): VCI: Vocabulary, Similarities PRI: Block Design*, Matrix Reasoning, Figure Weights* WMI: Digit Span (fwd/bwd/seq), Letter–Number Sequencing PSI: Coding, Symbol Search (* = paper/console analogs; the real subtests use physical materials) Commands: python iqgen.py gen --scale wais --seed 7 -> console test + HTML + key python iqgen.py score --scale wais -> enter raw scores, get report Educational tool only. Not a clinical instrument; calibration norms are transparent approximations you can edit in NORMS below. """ import argparse, datetime, json, math, os, random, sys LETTERS = "ABCDE" SHAPES = ["circle", "square", "triangle"] GLYPH = {("circle", True): "●", ("circle", False): "○", ("square", True): "■", ("square", False): "□", ("triangle", True): "▲", ("triangle", False): "△"} SYM_POOL = ["▲", "■", "●", "◆", "★", "✚", "◐", "♥", "▼", "◇", "□", "○", "♪", "✿"] ``` Hmm symbol search pool mixing shape glyphs with others fine. Continue with SVG helpers: ```python def shape_svg(shape, filled, cx, cy, r): st = 'stroke="#222" stroke-width="2"' body = f'fill="#222" {st}' if filled else f'fill="#fff" {st}' if shape == "circle": return f'' if shape == "square": return f'' return f'' CELL_POS = {1: [(25, 25)], 2: [(16, 25), (34, 25)], 3: [(25, 16), (16, 34), (34, 34)], 4: [(16, 16), (34, 16), (16, 34), (34, 34)]} def cell_svg(cell, x0, y0, s=50): if cell is None: return (f'' f'?') n, shape, filled = cell out = [f''] r = 8 if n <= 3 else 7 for (px, py) in CELL_POS[n]: out.append(shape_svg(shape, filled, x0 + px * s // 50, y0 + py * s // 50, r * s // 50)) return "".join(out) ``` Wait CELL_POS coordinates assume s=50. Scaling: px*s//50 with s=50 → px ✓. If I always call with s=50, drop scaling. Keep s=50 always. Simplify: no s param. `x0 + s//2` in text: use x0+25. def cell_text(cell): ```python def cell_text(cell): if cell is None: return "?" n, shape, filled = cell return GLYPH[(shape, filled)] * n ``` Matrix generation: ```python def gen_matrix(rng, tier, small): n = 2 if small else 3 shapes = rng.sample(SHAPES, 3) base_fill = rng.random() < 0.5 rule = {1: "count", 2: "shape_fill", 3: "count_shape", 4: "count_fill"}[tier] def mk(r, c): if rule == "count": return (c + 1, shapes[0], base_fill) if rule == "shape_fill": return (1, shapes[c % 3], base_fill if r % 2 == 0 else not base_fill) if rule == "count_shape": return (c + 1, shapes[r % 3], base_fill) filled = (r + c) % 2 == (0 if base_fill else 1) return (c + 1, shapes[0], filled) grid = [[mk(r, c) for c in range(n)] for r in range(n)] target = grid[-1][-1] grid[-1][-1] = None nopt = 4 if small else 5 maxn = 3 if small else 4 opts = [target] seen = {target} tries = 0 while len(opts) < nopt and tries < 80: tries += 1 kind = rng.choice(["count", "shape", "fill"]) n2, sh2, fl2 = target if kind == "count": d = rng.choice([-1, 1]) n2 = n2 + d if 1 <= n2 + d <= maxn else n2 - d elif kind == "shape": sh2 = rng.choice([s for s in SHAPES if s != sh2]) else: fl2 = not fl2 cand = (n2, sh2, fl2) if cand not in seen: seen.add(cand); opts.append(cand) while len(opts) < nopt: # fallback cand = (rng.randint(1, maxn), rng.choice(SHAPES), rng.random() < .5) if cand not in seen: seen.add(cand); opts.append(cand) rng.shuffle(opts) ans = LETTERS[opts.index(target)] return {"grid": grid, "options": opts, "answer": ans, "small": small} ``` Bug check: "count" mutation when n2+d out of range: `n2 = n2 + d if 1 <= n2 + d <= maxn else n2 - d` — if both out of range (n2=1, d=-1 → n2-d=2 ✓; n2=3 small max, d=+1 → 4 out → n2-d=2 ✓). Since maxn ≥ 3 and counts within [1..3] (target count = n ≤ 3), opposite direction always valid ✓. (For small, target count=2 → ±1 both fine.) Note for small "shape_fill": c%3 for c∈{0,1} → shapes[0],shapes[1]; target uses shapes[1] ✓. Console render matrix: ```python def matrix_console(item): g = item["grid"] lines = [] for row in g: lines.append(" ".join(cell_text(c).ljust(4) for c in row)) opts = " ".join(f"{LETTERS[i]}) {cell_text(o)}" for i, o in enumerate(item["options"])) return "\n".join(lines) + "\n Which cell completes the pattern?\n " + opts ``` Matrix svg: ```python def matrix_svg(item): g = item["grid"]; n = len(g); s = 50 parts = [f'") return "".join(parts) def options_svg(opts): s = 50 parts = [f'") return "".join(parts) ``` Block design gen: ```python def rot(g, k=1): out = [row[:] for row in g] for _ in range(k): out = [list(r) for r in zip(*out[::-1])] return out def flip_h(g): return [row[::-1] for row in g] def flip_v(g): return g[::-1] def mutate_one(g, rng): out = [row[:] for row in g] r = rng.randrange(len(out)); c = rng.randrange(len(out)) out[r][c] = 1 - out[r][c] return out def canon(g): return tuple(tuple(r) for r in g) def gen_block_design(rng, size): while True: g = [[rng.randint(0, 1) for _ in range(size)] for _ in range(size)] if 0 < sum(map(sum, g)) < size * size: break ks = [1, 2, 3]; rng.shuffle(ks) correct = None for k in ks: cand = rot(g, k) if canon(cand) != canon(g): correct = cand; break if correct is None: return gen_block_design(rng, size) # symmetric under all rotations; regenerate seen = {canon(correct), canon(g)} pool = [flip_h(g), flip_v(g), rot(flip_h(g), rng.choice([1,2,3]))] opts = [correct] for d in pool: if len(opts) >= 4: break if canon(d) not in seen: seen.add(canon(d)); opts.append(d) guard = 0 while len(opts) < 4 and guard < 50: guard += 1 d = mutate_one(g, rng) if canon(d) not in seen: seen.add(canon(d)); opts.append(d) rng.shuffle(opts) ans = LETTERS[opts.index(correct)] limit = {2: 30, 3: 45, 4: 60}[size] return {"model": g, "options": opts, "answer": ans, "limit_s": limit} ``` Wait — bug: opts.index(correct) — correct is a list-of-lists; equality works. But if correct got mutated? No, mutate_one works on copies ✓. Also ensure correct != g handled. Also distractor flip could equal correct? seen includes correct; flips of symmetric g might equal g → excluded ✓. Also I must ensure the MODEL isn't among options (it is excluded via seen containing canon(g)) ✓. One subtlety: is flip_v(g) possibly a rotation of g? E.g., some grids: flip_v == rot(g,2) for vertically symmetric... if so, flip_v == rot180; if correct=rot180 then flip_v would equal correct → excluded by seen ✓. But if correct is rot90 and flip_v equals rot90(g)? flip_v vs rot90 generally differ; regardless, seen-check prevents duplicates of correct; but a distractor could still be A rotation of g? Only correct is a rotation; distractors that happen to also be rotations of g would be... flips rarely equal rotations; if flip_v(g) == rot(g,1) it'd be excluded only if equal to correct. But if flip equals a DIFFERENT rotation (not the chosen correct), the item is still valid: participant must find the option that is a rotation matching model; another option being also a rotation would make TWO correct answers!! Check: if correct = rot(g,1) and flip_v(g) == rot(g,3), then option flip_v is also "the model rotated" → ambiguous!! Must exclude ALL rotations from distractors: add canon of rot(g,1), rot(g,2), rot(g,3) to seen before building distractors. ```python rotations = {canon(rot(g, k)) for k in (1, 2, 3)} seen = rotations | {canon(g), canon(correct)} ``` Since correct is one of the rotations ✓. Then distractors (flips/mutations) can't be any rotation ✓. Distractor pool: flips, flip-rotations, mutations — none are rotations of g (need check: rot(flip_h(g), k) could equal flip_h(g) itself; could rot(flip_h(g),k) coincide with some rot(g,j)? If flip_h(g) == rot(g,j) then flip_h is a rotation → then flip_h would be in rotations set... only if flip_h(g) EXACTLY equals a rotation; seen blocks it ✓). And mutate_one(g) differs from g by one cell; could equal a rotation? seen blocks ✓. Edge: pool might not provide 3 distractors (e.g., g where flips all coincide with rotations or g) → mutate fallback; mutations might collide with rotations — seen blocks; guard 50 fine. But wait — mutations of g: is a mutated grid possibly a rotation of ANOTHER mutated... irrelevant, only rotations of g are forbidden ✓. Also inv(g) as extra distractor? Could add to pool: inv = [[1-v ...]]. inv could be a rotation of g? possible for special g; seen blocks ✓. Add inv to pool for variety. Console for block design: ```python def grid_console(g, dark="█", light="·", hole="?"): return ["".join(dark if v == 1 else (light if v == 0 else hole) for v in row) for row in g] def grids_side_by_side(grids, gap=10): blocks = [] for g in grids: rows = grid_console(g) blocks.append(rows) lines = [] width = max(len(r) for b in blocks for r in b) for i in range(max(len(b) for b in blocks)): parts = [] for b in blocks: row = b[i] if i < len(b) else "" parts.append(row.ljust(width)) lines.append((" " * gap).join(parts).rstrip()) return lines ``` With labels: prepend labels row above each block column: build label row: first line = letters positioned. Implementation in print: print " " then label line: `(" "*gap).join(f"{LETTERS[i]})".ljust(width) for i ...)`. I'll fold labels into the side-by-side by adding label line at top of each block: ```python def grids_side_by_side(grids, letters_row, gap=10): ... blocks = [[f"{letter})"] + rows for ...]? ``` label then rows below — label line separate: block rows all same height; add label as first row of block: block = [label] + grid_console(g). Then widths: width = max row len. Then side-by-side. Simple ✓. For model without letter, label "". Visual puzzle: ```python def gen_visual_puzzle(rng, tier): mode = ["vm", "hm", "vi", "hi"][tier - 1] # mirror, plain or inverted while True: half = [[rng.randint(0, 1) for _ in range(2)] for _ in range(2)] # build base left/top half of 4x4 left = [row[:] for row in half] + [row[:] for row in half] # placeholder? ``` Hmm, build full 4x4 from a random 4x2 left half (for vertical mirror) or 2x4 top half (horizontal). For vertical mirror: g[i][j] = left[i][j] if j<2 else left[i][3-j]; vertical mirror with inversion: g[i][j] = left[i][j] if j<2 else 1-left[i][3-j]. For horizontal: g[i][j] = top[i][j] if i<2 else top[3-i][j]; inverted variant similar. Missing quadrant (qr, qc) ∈ {0,1}². Deducibility: - vertical mirror: block cells (i,j) with j ∈ {2,3} ← mirror of (i, 3-j) in cols {0,1} visible ✓ regardless of qr. If qc=0 (block on left): block (i,j∈{0,1}) ← mirror from cols {2,3} visible ✓. - horizontal mirror: rows analog ✓. So any quadrant works for both ✓. Block = 2x2 from g at (qr,qc). Options: correct + distractors from [inv(block), rot(block,1), rot(block,2), rot(block,3), flip_h(block), flip_v(block)] filtered ≠ correct, dedup, fill to 3 with random single-bit mutations ≠ correct... wait mutations of block could accidentally fit? No—correctness defined as exact original piece; mutations are wrong ✓. But also ensure distractor isn't accidentally equal to correct ✓ seen. Also ensure block is NOT uniform? Uniform block (all 0s): inv works as distractor ✓; rotations = block excluded; flips = block excluded; mutations: 2 distinct (one bit flipped) → total distractors: inv + 2 mutations = 3 ✓ OK fine. ```python def gen_visual_puzzle(rng, tier): inv = (tier - 1) % 2 == 1 # tiers: 1 vm, 2 hm, 3 vi, 4 hi vertical = tier in (1, 3) while True: if vertical: half = [[rng.randint(0, 1) for _ in range(2)] for _ in range(4)] g = [half[i][:] + [half[i][3 - j] if not inv_m... ] ... ``` Let me write explicitly: ```python while True: if vertical: L = [[rng.randint(0, 1) for _ in range(2)] for _ in range(4)] g = [[L[i][j] if j < 2 else (L[i][3 - j] if not inv else 1 - L[i][3 - j]) for j in range(4)] for i in range(4)] else: T = [[rng.randint(0, 1) for _ in range(4)] for _ in range(2)] g = [T[i][:] if i < 2 else ([T[3 - i][j] if not inv else 1 - T[3 - i][j] for j in range(4)]) for i in range(4)] qr, qc = rng.randrange(2), rng.randrange(2) block = [[g[qr + i][qc + j] for j in range(2)] for i in range(2)] if not all(v == block[0][0] for row in block for v in row): break # avoid uniform block (too easy / few distractors) disp = [row[:] for row in g] for i in range(2): for j in range(2): disp[qr + i][qc + j] = None cands = [invert(block), rot(block, 1), rot(block, 2), rot(block, 3), flip_h(block), flip_v(block)] opts = [block]; seen = {canon(block)} for d in cands: if len(opts) >= 4: break if canon(d) not in seen: seen.add(canon(d)); opts.append(d) guard = 0 while len(opts) < 4 and guard < 60: guard += 1 d = mutate_one(block, rng) if canon(d) not in seen: seen.add(canon(d)); opts.append(d) rng.shuffle(opts) ans = LETTERS[opts.index(block)] return {"display": disp, "options": opts, "answer": ans, "limit_s": 30 + tier * 10} ``` invert(g) = [[1 - v for v in row] for row in g]. Wait — distractor correctness: for the inverted-mirror pattern, inv(block) is plausibly attractive ✓. Also careful: a distractor might ACTUALLY complete the pattern equivalently? The completion is uniquely determined by the mirror rule; distractors that don't match the rule are wrong ✓. But one subtle issue: for vertical mirror with qc=0 (block on left), block = mirror of right side; distractor flip_h(block) = ... flip_h(block) mirrors the block horizontally = block from... could flip_h(block) coincidentally equal block (symmetric block) → excluded by seen ✓. Could a distractor ALSO satisfy the mirror rule? Only if it equals block → excluded ✓. Console: display grid with "?" holes; options side-by-side 2x2. Figure weights: ```python def _balance(va, vb, maxn=6): for na in range(1, maxn + 1): for nb in range(1, maxn + 1): if na * va == nb * vb: return na, nb return None def gen_figure_weights(rng, tier): shapes = ["circle", "square", "triangle"] while True: va, vb, vc = rng.sample(range(2, 7), 3) ab = _balance(va, vb); bc = _balance(vb, vc) if ab and bc: break na, nb = ab; mb, mc = bc nc = rng.randint(1, 3) T = nc * vc correct = None combos = [] for xa in range(7): for xb in range(7): for xc in range(7): if (xa, xb, xc) == (0, 0, 0): continue v = xa * va + xb * vb + xc * vc if v == T and 2 <= xa + xb + xc <= 4: combos.append((xa, xb, xc)) if not combos: return gen_figure_weights(rng, tier) rng.shuffle(combos) correct = combos[0] seen = {correct} opts = [correct] # distractors: mutate one count; also combos with nearby values guard = 0 while len(opts) < 4 and guard < 200: guard += 1 xa, xb, xc = correct mut = list(correct) i = rng.randrange(3) mut[i] = max(0, mut[i] + rng.choice([-1, 1])) mut = tuple(mut) if mut == (0, 0, 0): continue if mut not in seen and (mut[0]*va + mut[1]*vb + mut[2]*vc) != T: seen.add(mut); opts.append(mut) # fill with random non-balancing combos if short while len(opts) < 4: mut = tuple(rng.randint(0, 4) for _ in range(3)) if mut == (0,0,0) or mut in seen: continue if mut[0]*va+mut[1]*vb+mut[2]*vc == T: continue seen.add(mut); opts.append(mut) rng.shuffle(opts) ans = LETTERS[opts.index(correct)] scales = [((na, 0, 0), (0, nb, 0)), ((0, mb, 0), (0, 0, mc)), ((0, 0, nc), None)] return {"scales": scales, "options": opts, "answer": ans, "values": (va, vb, vc)} ``` Hmm wait: scales[2] right side None = unknown (the ?). Display: left glyphs "▲▲", right "?". Rendering combo (xa,xb,xc) → "●"*xa + "■"*xb + "▲"*xc. But hold on — scale 2 shows mb squares vs mc triangles: from _balance(vb,vc) we got (mb, mc) with mb*vb = mc*vc ✓. And scale1: na*va = nb*vb ✓. Chain: participant infers A:B and B:C → find combo == nc*C ✓. Wait, one issue: distractor mutation uses `max(0, ...)` — count 0 fine; (0,0,0) skipped ✓. Also possible: correct uses only C shapes, e.g., (0,0,nc) → trivially "▲▲ = ▲▲"?? T = nc*vc; combo (0,0,nc) gives value nc*vc = T → included if nc ≤ 4! That's a trivial answer (same shape as left side). It's still CORRECT mathematically — the real test also allows such? Real figure weights answers involve the target shapes; having a trivial same-shape option would make it too easy. Exclude combos with xc > 0? Hmm — but then higher-tier items lose some richness. Simpler: require xc == 0 in correct combo (answer expressed in A and B only) — forces the inference chain ✓. Adjust: combos only over xa, xb with xc=0: value = xa*va + xb*vb == T. If none exist with 2..4 total glyphs, regenerate. E.g., va=2,vb=3,vc=4, nc=2 → T=8: combos: (4,0)=8 ✓ (4 glyphs), (1,2)=8 ✓ 3 glyphs ✓. Good. Distractors: mutate counts of correct (xa,xb only): (1,2)→(2,2)=10, (0,2)=6, (1,1)=5, (1,3)=11 ✓ plenty. Redo: ```python combos = [] for xa in range(1, 7): for xb in range(0, 7): if xa * va + xb * vb == T and 2 <= xa + xb <= 5: combos.append((xa, xb)) ``` require xa ≥ 1 (at least one A). Distractors mutate. Display strings accordingly: "●■■". Also keep correct combo glyphs ≤ 5. Also, values: ensure va≠vb etc. via sample ✓. And va,vb,vc from 2..6; balance exists when... e.g., va=5, vb=3: 3*5=15=5*3 ✓ na=3,nb=5 ≤ 6 ✓. va=5,vb=2: 2*5=10=5*2 ✓. Any pair with product ≤ 36: na=vb? For coprime-ish: na = vb/g * ... For va,vb ≤ 6: na ≤ 6 needed: minimal solution na = vb/gcd, nb = va/gcd → both ≤ 6 ✓ always! Great — balance always exists within range ✓. Tier scaling: tier 1-2: nc = 1-2, values 2..4; tier 3-4: values 2..6, nc 1..3. Implement: rng.sample(range(2, 5 if tier<=2 else 7), 3). LNS: ```python def gen_lns(rng): trials = [] letters = "BCDFGHJKLMNPQRSTV" for L in range(2, 9): nd = max(1, L // 2) for _ in range(2): lts = rng.sample(letters, L - nd) dgs = [rng.randint(1, 9) for _ in range(nd)] seq = lts + [str(d) for d in dgs] rng.shuffle(seq) ans = [str(d) for d in sorted(dgs)] + sorted(lts) trials.append({"len": L, "seq": seq, "answer": ans}) return trials ``` Careful: L - nd could be 0 if nd == L? nd = max(1, L//2) ≤ L//2 + ...: for L=2: nd=1, lts=1 ✓. For L≥2, L//2 ≤ L-1 ✓ so L-nd ≥ 1 ✓ (always at least one letter, at least one digit ✓). Wait: for L=2: nd = max(1, 1) = 1; lts = 1 ✓. Digit span: ```python def gen_digit_span(rng): trials = [] for kind, lo, hi in [("forward", 3, 9), ("backward", 2, 8), ("sequencing", 3, 9)]: for L in range(lo, hi + 1): for _ in range(2): seq = [rng.randint(0, 9) for _ in range(L)] if kind == "forward": ans = seq[:] elif kind == "backward": ans = seq[::-1] else: ans = sorted(seq) trials.append({"kind": kind, "len": L, "seq": seq, "answer": ans}) return trials ``` Coding: ```python def gen_coding(rng, n): syms = rng.sample(SYM_POOL[:9], 9) key = {d: syms[d - 1] for d in range(1, 10)} digits = [rng.randint(1, 9) for _ in range(n)] return {"key": key, "digits": digits} ``` SYM_POOL[:9] — first 9 symbols: ["▲","■","●","◆","★","✚","◐","♥","▼"] distinct ✓. But symbol search uses same pool → same symbols across subtests fine. Symbol search: ```python def gen_symbol_search(rng, n): pool = SYM_POOL rows = [] for _ in range(n): targets = rng.sample(pool, rng.choice([1, 2])) others = [p for p in pool if p not in targets] present = rng.random() < 0.5 k = rng.choice([4, 5, 6]) if present: group = rng.sample(others, k - 1) + [rng.choice(targets)] rng.shuffle(group) else: group = rng.sample(others, k) rows.append({"targets": targets, "group": group, "answer": "Y" if present else "N"}) return rows ``` len(others) ≥ 12 ≥ k-1 ✓ (k ≤ 6). Arithmetic: ```python def gen_arithmetic(rng, tier): if tier == 1: a, b = rng.randint(5, 15), rng.randint(2, 9) if rng.random() < 0.5: return (f"A shelf held {a} books and {b} more were added. How many books now?", a + b) return (f"Ella had {a} marbles and lost {b}. How many left?", a - b) if tier == 2: k, each = rng.randint(3, 6), rng.randint(3, 9) total = k * each return (f"{total} stickers are shared equally among {k} friends. How many stickers each?", each) if tier == 3: if rng.random() < 0.5: v, t = rng.choice([40, 50, 60, 80]), rng.choice([2, 3]) return (f"A train travels steadily at {v} km/h. How far does it travel in {t} hours?", v * t) price = rng.randint(2, 9); paid = price + rng.randint(1, 10) → change with coins? "paid with a 20 note, price price euros"? price = rng.randint(4, 15); paid = rng.choice([20, 50]) while paid <= price: paid *= 2? ``` Let me simplify tier3: two variants: train distance; or "total price of a items at b euros each": (f"{a} notebooks cost {a*b}... ") hmm: "One notebook costs {b} euros. How much do {a} notebooks cost?" — that's multiplication ≈ tier2? Make tier3: change: price 3-12, paid 20 → change = 20 - price. Fine: ```python price = rng.randint(3, 18) return (f"You buy a book for {price} euros and pay with a 20-euro note. How much change?", 20 - price) ``` tier4: ```python if rng.random() < 0.5: p = rng.choice([10, 20, 25, 50]); n = rng.choice([20, 40, 60, 80, 120]) return (f"What is {p}% of {n}?", n * p // 100) nums = [rng.randint(2, 25) for _ in range(3)] while sum(nums) % 3 != 0: nums[rng.randrange(3)] += 1 return (f"A sprinter ran {nums[0]}, {nums[1]} and {nums[2]} metres in three races. What is the average distance?", sum(nums) // 3) ``` Vocabulary generation: bank is list of (tier, word, k2, k1). Sort by tier; select 4 per tier — bank has exactly 4 per tier (16). Sample all 16 in tier order (shuffle within tier): ```python def gen_vocab(rng, bank): items = [] for t in range(1, 5): tier_words = [w for w in bank if w[0] == t] rng.shuffle(tier_words) items.extend(tier_words) return items # each: (tier, word, k2, k1) ``` Similarities: ```python def gen_similarities(rng, bank_cats): pairs = [] used = set() pool = list(bank_cats) tries = 0 while len(pairs) < 12 and tries < 100: tries += 1 cat = pool[len(pairs) % len(pool)] a, b = rng.sample(cat["items"], 2) if (a, b) in used: continue used.add((a, b)); used.add((b, a)) pairs.append({"pair": (a, b), "tier": cat["tier"], "cat": cat["name"], "abstract": cat["abstract"], "concrete": cat["concrete"]}) return pairs ``` Each cat has ≥ 8 items → many pairs; 12 pairs from pool of 8-9 cats fine. Cat tiers: assign tier by position: cats ordered; tier = min(4, idx//3 + 1)? With 12 cats: idx 0-2→1, 3-5→2, 6-8→3, 9-11→4 ✓. WISC pool = cats[:8] (tiers 1-3); WAIS pool = cats[3:] (tiers 2-4). Both length 8/9 → 12 pairs cycling ✓. Information: bank list (tier, q, a): 16 items; shuffle within tier, extend in tier order. Now assembly: ```python def generate(scale, seed, name): rng = random.Random(seed) T = {"scale": scale, "seed": seed, "name": name, "date": datetime.datetime.now().isoformat(timespec="seconds"), "subtests": {}} S = T["subtests"] S["vocabulary"] = {"items": gen_vocab(rng, WAIS_VOCAB if scale == "wais" else WISC_VOCAB)} S["similarities"] = {"items": gen_similarities(rng, SIM_CATS[3:] if scale == "wais" else SIM_CATS[:8])} if scale == "wais": S["information"] = {"items": gen_info(rng, WAIS_INFO)} sizes = [2, 2, 3, 3, 4, 4] if scale == "wais" else [2, 2, 2, 2, 3, 3] S["block_design"] = {"items": [gen_block_design(rng, z) for z in sizes]} S["matrix_reasoning"] = {"items": [gen_matrix(rng, 1 + i // 4, scale == "wisc" and 1 + i // 4 <= 2) for i in range(16)]} if scale == "wais": S["visual_puzzles"] = {"items": [gen_visual_puzzle(rng, 1 + i % 4) for i in range(10)]} else: S["figure_weights"] = {"items": [gen_figure_weights(rng, 1 + i // 3) for i in range(12)]} S["digit_span"] = {"items": gen_digit_span(rng)} if scale == "wais": S["arithmetic"] = {"items": [gen_arithmetic(rng, 1 + i // 4) for i in range(16)]} else: S["letter_number"] = {"items": gen_lns(rng)} S["coding"] = gen_coding(rng, 100 if scale == "wais" else 80) S["symbol_search"] = {"items": gen_symbol_search(rng, 40)} return T ``` Wait matrix small condition: small = (scale=="wisc" and tier ≤ 2). Tier = 1 + i//4 → i//4 ∈ {0,1,2,3} → tiers 1..4, 4 items each ✓. gen_info: ```python def gen_info(rng, bank): items = [] for t in range(1, 5): tier_qs = [q for q in bank if q[0] == t] rng.shuffle(tier_qs) items.extend(tier_qs) return items ``` Console printing — the big function. Subtest instructions map: ```python SUBTEST_META = { "vocabulary": ("Vocabulary", "VCI", "Ask: “What does ___ mean?” 30 s each. Score 0/1/2 (see key). Stop after 4 consecutive 0s."), ... } ``` Let me define labels + instructions per subtest with scale-appropriate wording. I'll write print functions per subtest keyed by name. Console printer: ```python def hr(ch="─", n=72): return ch * n def print_test(T): scale = T["scale"] print(hr("═")) title = "WAIS-STYLE" if scale == "wais" else "WISC-STYLE" print(f" {title} FSIQ PRACTICE BATTERY — original generated items") print(f" Examinee: {T['name'] or '—'} Seed: {T['seed']} {T['date']}") print(" Educational practice tool — NOT a clinical IQ test.") print(hr("═")) cur_idx = None for idx, sub in ORDER[scale]: if idx != cur_idx: cur_idx = idx print(); print(hr("─")); print(f" {IDX_FULL[idx]}"); print(hr("─")) print_subtest(sub, T["subtests"][sub]) ``` print_subtest dispatch dict: {"vocabulary": pv, ...}. Each prints header + instructions + items. Let me write each console printer: ```python def hdr(sub): name, idx, ins = SUBTEST_META[sub] print(f"\n▶ {name} [{idx}]") print(f" {ins}") ``` Vocabulary: ```python def p_vocab(sub, data): hdr(sub) for i, (t, w, k2, k1) in enumerate(data["items"], 1): print(f" {i:2}. {w:<14} ") ``` Answer space on paper — fine. Similarities: ```python print(f" {i:2}. {a} — {b} (alike how?)") ``` Information: ```python print(f" {i:2}. {q}") ``` Arithmetic: same with "(no paper)" note in instructions. Digit span: ```python def p_digit_span(sub, data): hdr(sub) instr = {"forward": "Repeat in the SAME order.", "backward": "Repeat in REVERSE order.", "sequencing": "Repeat lowest → highest."} for kind in ("forward", "backward", "sequencing"): print(f"\n {kind.upper()} — {instr[kind]} (read aloud 1 digit/second, or reveal each row for len seconds then cover)") for t in [x for x in data["items"] if x["kind"] == kind]: print(f" {t['len']} digits: {' '.join(map(str, t['seq']))}") ``` Grouping trials by kind in original order — items list already grouped by kind ✓ can iterate sequentially with kind-change detection. LNS: ```python print(f" {' '.join(t['seq'])} → digits low→high, then letters A→Z") ``` Block design: ```python def p_block(sub, data): hdr(sub) for i, it in enumerate(data["items"], 1): print(f"\n {i}. Which option is the SAME design rotated? ({it['limit_s']} s)") rows = grid_console(it["model"]) print(" Model: " + " | ".join? ``` Show model left, options right side-by-side: ```python for r in rows: print(" " + r) print(" Options:") lines = grids_side_by_side(it["options"], letters="ABCD") ``` grids_side_by_side with label header per block: implement: ```python def grids_side_by_side(grids, letters, gap=8): blocks = [] for g, L in zip(grids, letters): rows = grid_console(g) blocks.append([f"{L})"] + [" " * 3] * 0 + rows) ``` Hmm label line then rows: block = [f"{L})"] + rows. Then width per block = max(len(s) for s in block). Compose line by line: ```python def grids_side_by_side(grids, letters, gap=8, indent=" "): blocks = [] for g, L in zip(grids, letters): rows = grid_console(g) blocks.append([f"{L})"] + rows) nlines = max(len(b) for b in blocks) widths = [max(len(s) for s in b) for b in blocks] out = [] for i in range(nlines): seg = [(" " if i == 0 and False else "")] ``` Write plainly: ```python for i in range(nlines): parts = [] for b, w in zip(blocks, widths): s = b[i] if i < len(b) else "" parts.append(s.ljust(w)) out.append(indent + (" " * gap).join(parts).rstrip()) return out ``` ✓. For model display use same with letters [""]. Matrix console: ```python def p_matrix(sub, data): hdr(sub) for i, it in enumerate(data["items"], 1): print(f"\n {i}. Complete the matrix:") for row in it["grid"]: print(" " + " ".join(cell_text(c).ljust(3) for c in row)) print(" " + " ".join(f"{LETTERS[j]}) {cell_text(o)}" for j, o in enumerate(it["options"]))) ``` Visual puzzles: ```python display rows with "?" → hole: for row in it["display"]: print(" " + "".join("█" if v==1 else ("·" if v==0 else "?") for v in row)) options side-by-side 2x2 ``` Figure weights: ```python for k, (l, r) in enumerate(it["scales"], 1): lt = combo_str(l); rt = combo_str(r) if r else "?" print(f" Scale {k}: {lt} balances {rt}") print options A) ... ``` combo_str((xa,xb,xc)) = "●"*xa+"■"*xb+"▲"*xc. Coding: ```python def p_coding(sub, data): hdr(sub) # instructions: 120 s key = data["key"] print(" KEY: " + " ".join(f"{d}={s}" for d, s in key.items())) print(" Fill the symbol under each digit. Start the clock at the first row.") per = 10 for i in range(0, len(data["digits"]), per): chunk = data["digits"][i:i+per] print(" " + " ".join(str(d) for d in chunk)) print(" " + " ".join("▢" for _ in chunk)) ``` Symbol search: ```python print(" Mark ✓ if any TARGET appears in the GROUP, ✗ if not. 120 s.") for i, row in enumerate(data["items"], 1): print(f" {i:2}. {' '.join(row['targets'])} | {' '.join(row['group'])} | ___") ``` Key JSON: ```python def build_key(T): key = {"scale": T["scale"], "seed": T["seed"], "norms": NORMS[T["scale"]], "battery": BATTERY[T["scale"]], "answers": {}} A = key["answers"] S = T["subtests"] A["vocabulary"] = [{"word": w, "2pts": k2, "1pt": k1} for (t, w, k2, k1) in S["vocabulary"]["items"]] A["similarities"] = [{"pair": p["pair"], "2pts": p["abstract"], "1pt": p["concrete"]} for p in S["similarities"]["items"]] if "information" in S: A["information"] = [q[2] for q in S["information"]["items"]] A["block_design"] = [it["answer"] for it in S["block_design"]["items"]] A["matrix_reasoning"] = [it["answer"] for it in S["matrix_reasoning"]["items"]] if "visual_puzzles" in S: A["visual_puzzles"] = [it["answer"] for it in ...] if "figure_weights" in S: A["figure_weights"] = [...] A["digit_span"] = [{"kind":..., "seq":..., "answer":...} ...] if "arithmetic" in S: A["arithmetic"] = [q[1] for q in S["arithmetic"]["items"]] if "letter_number" in S: A["letter_number"] = [{"seq":..., "answer":...}...] A["coding"] = [[data["key"][d] for d in chunk...] ...] or flat list A["symbol_search"] = [row["answer"] ...] return key ``` Coding key: flat list of symbols aligned with digits; plus chunking at print. Store "digits" & "symbols" lists. Scoring: ```python NORMS = {...} # per scale: subtest: dict(max, mu, sd) BATTERY = {"wais": {...}, "wisc": {...}} def zscore(raw, spec): return (raw - spec["mu"]) / spec["sd"] def classify(x): if x >= 130: return "Very Superior" if x >= 120: return "Superior" if x >= 110: return "High Average" if x >= 90: return "Average" if x >= 80: return "Low Average" if x >= 70: return "Borderline" return "Extremely Low" def percentile(z): return round(100 * 0.5 * (1 + math.erf(z / math.sqrt(2))), 1) def score_mode(scale): norms = NORMS[scale]; bat = BATTERY[scale] print(...) raws = {} for idx in ("VCI","PRI","WMI","PSI"): print(f"\n{idx} ({IDX_FULL[idx]})") for sub in bat[idx]: spec = norms[sub] lo = -spec["max"] if sub == "symbol_search" else 0 while True: try: v = int(input(f" {LABELS[sub]} raw ({lo}–{spec['max']}): ").strip()) if lo <= v <= spec["max"]: break except ValueError: pass print(" Enter an integer in range.") raws[sub] = v # per-subtest scaled print("\n" + hr("─")) print(" SUBTEST PROFILE (scaled: M=10, SD=3)") rows = [] for idx in ("VCI","PRI","WMI","PSI"): for sub in bat[idx]: z = zscore(raws[sub], norms[sub]) sc = max(1, min(19, round(10 + 3 * z))) rows.append((idx, LABELS[sub], raws[sub], sc)) print(f" {LABELS[sub]:<22} raw {raws[sub]:>3} scaled {sc:>2}") idx_scores = {} for idx in ("VCI","PRI","WMI","PSI"): zs = [zscore(raws[s], norms[s]) for s in bat[idx]] z = sum(zs) / len(zs) sc = int(round(100 + 15 * z)) idx_scores[idx] = (min(160, max(40, sc)), z) zf = sum(z for _, z in idx_scores.values()) / 4 fsiq = int(round(100 + 15 * zf)) print("\n INDEX SCORES (M=100, SD=15)") for idx in (...): sc, z = idx_scores[idx] print(f" {idx} {IDX_FULL[idx]:<34} {sc:>3} ({percentile(z)}th %ile)") print("\n" + hr("═")) print(f" FSIQ ESTIMATE: {fsiq} ({percentile(zf)}th percentile) {classify(fsiq)}") print(f" Approx. 95% CI: {fsiq - 9} – {fsiq + 9} (assumed reliability .90)") print(" NOTE: practice battery with approximate norms; not a clinical result.") ``` Hmm LABELS subtest display names: "Vocabulary", "Similarities", "Information", "Block Design", "Matrix Reasoning", "Visual Puzzles", "Figure Weights", "Digit Span", "Arithmetic", "Letter–Number Seq.", "Coding", "Symbol Search". HTML builder — let me write: ```python def html_escape(s): return s.replace("&","&").replace("<","<").replace(">",">") HTML_HEAD = """ {title}

{title}

Examinee: {name} Scale: {scale} Seed: {seed} Date: {date}

Generated practice battery of original items in the style of the four FSIQ domains. Educational use only — not a clinical or official IQ assessment.

""" ``` Then sections built per subtest; each returns html string; join; add key section; close body. HTML per subtest: - h3 header + instructions. - vocabulary: items `

{i}. {word}

` - similarities: similar with pair. - info/arithmetic: question + blank. - digit span: per kind table: rows digits; examiner note to cover. Table with a "cover" note. I'll show digits table and blank row. - block design: model grid_svg + options grid_svgs with letters. - matrix: matrix_svg + options_svg + blank "Answer: ___". - visual puzzles: display grid_svg (with holes) + options. - figure weights: weights svg (or styled text) + options text; blank. - coding: key table + digit rows tables (20 per row) with answer cells `td.a`. - symbol search: table rows. Key section: table per subtest with answers; for vocab: word + 2pts/1pt keywords; etc. weights_svg implementation: ```python def weights_svg(item): scales = item["scales"] W = 260; rowh = 78 parts = [f'") return "".join(parts) ``` Glyph unicode in SVG text — fine. combo_str: ```python def combo_str(c): if c is None: return "?" xa, xb, xc = c return "●" * xa + "■" * xb + "▲" * xc ``` Wait scales entries: ((na,0,0),(0,nb,0)) etc. Left side of scale3 is (0,0,nc) → "▲▲"; right None → "?" ✓. grid_svg: ```python def grid_svg(g, cell=26): h = len(g); w = len(g[0]) parts = [f'") return "".join(parts) ``` Coding HTML: key line as table; rows of 20: ```python def coding_html(data): per = 20 key = " ".join(f"{d} = {s}" for d, s in data["key"].items()) h = [f'

KEY: {key}

', '

120 seconds. Write the symbol for each digit in the box below it. Score = number correct.

'] for i in range(0, len(data["digits"]), per): chunk = data["digits"][i:i + per] h.append('

' + "".join(f"" for d in chunk) + "") h.append("" + '' * len(chunk) + "

{d}

") return "".join(h) ``` Symbol search html table: ```python rows = "".join(f"{' '.join(r['targets'])}{' '.join(r['group'])}" for r in data["items"]) '' + rows + '

Targets	Group	Y / N

' ``` Digit span html: for self-test flash issue, examiner reads; show digits in a table per trial row with answer boxes grouped by kind: ```python def digit_span_html(data): out = [] for kind in ("forward","backward","sequencing"): out.append(f"

{kind.capitalize()}

{SPAN_INSTR[kind]} Present each row aloud at ~1 digit/second, then have the examinee repeat/write it.

") rows = [t for t in data["items"] if t["kind"] == kind] out.append("") for t in rows: out.append(f"") out.append("

Length	Digits (examiner only)
{t['len']}	{' '.join(map(str, t['seq']))}

") ``` OK. Now HTML assembly function: ```python def render_html(T): scale = T["scale"]; S = T["subtests"] title = ("WAIS-style" if scale == "wais" else "WISC-style") + " FSIQ Practice Battery" parts = [HTML_HEAD.format(title=title, name=html_escape(T["name"] or "—"), scale=scale.upper(), seed=T["seed"], date=T["date"])] cur = None for idx, sub in ORDER[scale]: if idx != cur: cur = idx parts.append(f"

{idx} — {IDX_FULL[idx]}

") name, _idx, ins = SUBTEST_META[sub] parts.append(f"

{name}

{ins}

") parts.append(SUB_HTML[sub](S[sub])) # key parts.append('

Examiner Key

Seed ' + str(T["seed"]) + ' — keep separate from examinee.

') key = build_key(T) parts.append(key_html(key, T)) parts.append("

") return "".join(parts) ``` key_html: iterate battery; print tables of answers. I'll write generic: for vocab/similarities include keywords. Implement compactly. Wait — SUB_HTML dict maps sub → function(data). Define each. This is a lot of functions; maybe unify: one function with if/elif on sub. Fine, single `subtest_html(sub, data)` with branches. Same for console: single `print_subtest(sub, data)` with branches. Cleaner than dict of functions. Also SUBTEST_META instructions text: - vocabulary: 'Ask: "What does ___ mean?" One answer per word, ~30 s. Score 0/1/2 per key. Stop after 4 consecutive 0s.' - similarities: '"How are X and Y alike?" ~30 s. 2 = abstract, 1 = concrete, 0 = wrong/don't know. Stop after 4 consecutive 0s.' - information: 'General-knowledge questions, 30 s each, 1/0.' - block_design: 'Each item: pick the option that is the SAME design rotated (not flipped/mirrored). Timed per item.' (paper analog of the real block task) - matrix_reasoning: 'Pick the option that completes the pattern. ~30 s each. No time bonus.' - visual_puzzles: 'The picture follows a mirror rule; choose the piece that completes it.' - figure_weights: 'Shapes have hidden weights; pick the option that balances the last scale.' - digit_span: 'Read digits aloud ~1/second. Forward: same order. Backward: reverse. Sequencing: lowest→highest. 2 trials per length; stop that condition after failing both trials of one length.' - arithmetic: 'Mental math word problems — no paper or pencil, 45 s each.' - letter_number: 'Read mixed letters/digits aloud ~1/s. Examinee repeats digits first (low→high), then letters (A→Z). 2 trials per length.' - coding: 'Copy the matching symbol under each digit. 120 seconds total. Raw = number correct.' - symbol_search: 'Mark Y if any target appears in the group, N if not. 120 seconds. Raw = correct − incorrect.' IDX_FULL = {"VCI": "Verbal Comprehension", "PRI": "Perceptual Reasoning", "WMI": "Working Memory", "PSI": "Processing Speed"}. For WISC PRI, technically VSI+FRI; keep PRI label for the 4-part structure (WISC-IV style) and mention in docs. Main CLI: ```python def main(): ap = argparse.ArgumentParser(description="WAIS/WISC-style FSIQ practice generator") ap.add_argument("command", choices=["gen", "score"]) ap.add_argument("--scale", choices=["wais", "wisc"], required=True) ap.add_argument("--seed", type=int) ap.add_argument("--name", default="") ap.add_argument("--no-html", action="store_true") a = ap.parse_args() if a.command == "score": score_mode(a.scale); return seed = a.seed if a.seed is not None else random.randrange(10 ** 9) T = generate(a.scale, seed, a.name) print_test(T) key = build_key(T) base = f"{a.scale}_seed{seed}" with open(base + "_key.json", "w", encoding="utf-8") as f: json.dump(key, f, ensure_ascii=False, indent=1) if not a.no_html: with open(base + "_test.html", "w", encoding="utf-8") as f: f.write(render_html(T)) print(f"\n[saved] {base}_test.html") print(f"[saved] {base}_key.json") ``` Also print score instructions at end of gen: "After administration: python iqgen.py score --scale {scale}". Check every subtest referenced in ORDER exists in generated dict per scale ✓ per generate(). One more: print_test for WISC/WAIS must handle optional subtests via ORDER (per scale) ✓ — print only those in ORDER[scale] ✓. For console, also print the raw-score definitions at end (scoring guide): list per subtest: how to compute raw. Add a final section in print_test: ``` SCORING: raw scores per subtest → run score mode. vocabulary: Σ(0-2)/word; similarities: Σ(0-2); information: #correct; ... ``` I'll print a brief scoring cheat-sheet from SUBTEST_META raw definitions. Add "raw" field to SUBTEST_META. SUBTEST_META entries: (display, idx, instructions, raw_def). OK — also the vocab word display width ljust(14) might interact with wide glyphs? Vocab is ASCII words fine. Similarities items are ASCII ✓. Symbol glyphs in options lines — fine. Let me also double check matrix console for small grids: cells counts max 3 in 2x2 (c+1 with c≤1 → 2; distractors ≤ 3) ✓. For 3x3 distractor count max 4 while CELL_POS supports up to 4 ✓ (maxn=4). Wait CELL_POS[4] defined ✓; count 5 would break — maxn=4 prevents ✓. In matrix "count" rule counts = c+1 ≤ 3 ✓; distractor +1 → 4 ✓ ok. Block design option count = 4 always (A-D) ✓ letters "ABCD". Matrix options: 5 (3x3) → LETTERS[0:5] ✓; 4 (2x2) → A-D ✓. Figure weights options: 4 ✓. Visual puzzles options: 4 ✓. Coding key dict iteration order: Python dicts preserve insertion order; key built as {d: ...} d=1..9 ✓ ordered. Also careful: json dump of key includes tuples → lists fine. Now, similarites gen: pool cycling uses pairs len index — with pool of 8 cats and 12 pairs, cats 0..7 then 0..3 again; used-set prevents duplicates; potential infinite loop if a cat's items exhausted — 8 items → C(8,2)=28 pairs per cat, only ~2 uses per cat max ✓. Vocab banks need EXACTLY 4 per tier for 16 items — yes I'll write banks accordingly. Actually gen_vocab doesn't verify counts; I'll just write banks with exactly 4 per tier ✓ (16 words each scale). Max = 32 ✓ matches NORMS. INFO bank: exactly 4 per tier (16) ✓ matches NORMS max 16. Arithmetic: 16 items (4 per tier) ✓ max 16 ✓. Matrix: 16 ✓. Block: 6 ✓. Puzzles: 10 ✓. Weights: 12 ✓. DS: 42 ✓ (7+7+7 lengths ×2). LNS: 7 lengths ×2 = 14 ✓. Coding: 100/80 ✓. SS: 40 ✓. WISC battery ORDER: vocabulary, similarities, block, matrix, weights, digit_span, letter_number, coding, symbol_search → 9 subtests ✓. WAIS: vocab, sim, info, block, matrix, puzzles, ds, arithmetic, coding, ss → 10 ✓. NORMS keys must cover all subtests per scale ✓. Edge: score_mode input for letter_number label length etc. fine. Let me also add a tiny "warm-up/sample" note? Skip. Double-check HTML_HEAD format braces: I used .format with {title} etc. and CSS braces `{{` escaped ✓ — must be careful writing final: in the actual code the CSS must use double braces if using str.format. I'll use .format(title=..., name=..., scale=..., seed=..., date=...). All CSS braces doubled. Careful writing. Alternatively use f-string composition to avoid brace-escaping bugs. I'll build head via string concatenation with placeholders using % or f-string directly: ```python head = ('' + title + '' '

' + title + '

...') ``` Concatenation avoids format-brace pitfalls ✓. I'll do that. Also unicode in HTML must have charset ✓. Potential issue: console on Windows cmd with cp1252 may choke on ▢ etc. — note in docs: run in UTF-8 terminal (modern terminals fine; PYTHONIOENCODING=utf-8 fallback). Now, the response structure: 1. Short intro: what FSIQ's four parts are for each scale, disclaimers (original items, not clinical). 2. The single script (combining both generators). 3. How to use (commands, what outputs). 4. Scoring model explanation (raw→scaled→index→FSIQ; calibration editable). 5. Notes/limitations: auditory spans, physical blocks approximations, real norms, WISC-V has 5 indices note. Keep prose concise; code is the star. Format with headers and a table for the battery composition. Given the request's scale, a long response is appropriate, but I'll avoid fluff. Let me write the final code carefully in full now, consolidating all pieces, watching syntax. Also, one thing: `mutate_one` used before defined in block design — order functions properly. Also for `gen_visual_puzzle` tier cycling: tiers 1..4 over 10 items: tier = 1 + i % 4 ✓. For figure weights tier: 1 + i//3 → tiers 1..4 over 12 ✓ (3 each). Let me also make sure `gen_matrix` "shape_fill" rule for 3x3? tier2 small only; but WAIS tier2 → small=False, rule "shape_fill" with n=3: shapes[c%3] all distinct per col; fill alternates rows ✓ valid 3x3 too ✓. Now write vocab banks fully. Also SIM_CATS with tiers: ```python SIM_CATS = [ ("animals", 1, ["animal", "living thing", "creature", "mammal"], ["four legs", "fur", "tail", "pets"], ["dog","cat","horse","cow","rabbit","lion","mouse","elephant","goat","sheep"]), ... ] ``` Use tuples: (name, tier, abstract, concrete, items). Tier assign: I'll hardcode tier per cat. List with tiers: 1: animals, fruits 2: vehicles, clothes 3: furniture, tools 4: musical instruments, sports? Hmm order by abstractness: tools→"tools" abstract for kids is medium. Fine: t1: animals, fruits; t2: vehicles, clothes; t3: furniture, tools; t4: instruments? Let me assign: t1 animals fruits; t2 vehicles clothes furniture; t3 tools instruments sports birds; t4 emotions sciences seasons. That's 12 cats ✓ (2/3/4/3). WISC pool = tiers ≤3 → cats[0:9]; WAIS pool = tiers ≥2 → cats[2:12] (10 cats). Fine adjust gen: pool by tier filter. ```python def gen_similarities(rng, low_tier, high_tier): pool = [c for c in SIM_CATS if low_tier <= c[1] <= high_tier] ``` WISC: (1,3); WAIS: (2,4). Items per cat ≥ 8 for pairs ✓ let me ensure each cat has ≥8 items. I'll write 8-10 items each. Full SIM_CATS (name, tier, abstract, concrete, items): 1. animals t1: items 10 ✓ 2. fruits t1: apple banana orange pear grape melon plum peach mango cherry ✓ 3. vehicles t2: car bus bicycle truck train airplane boat tram scooter ✓ 4. clothes t2: shirt trousers sweater dress skirt sock jacket coat scarf ✓ 5. furniture t2: table chair sofa bed shelf cupboard desk stool bench ✓ 6. tools t3: hammer saw screwdriver wrench drill chisel pliers axe file ✓ 7. instruments t3: guitar piano violin drum flute cello trumpet harp organ ✓ 8. sports t3: soccer tennis swimming golf basketball gymnastics boxing rowing judo ✓ 9. birds t3: eagle sparrow owl pigeon crow parrot swan duck goose ✓ 10. emotions t4: anger joy fear sadness envy pride shame delight disgust ✓ 11. sciences t4: physics biology chemistry history geography economics astronomy psychology geology ✓ 12. seasons t4: summer winter autumn spring → only 4 items → pairs limited: C(4,2)=6 pairs ✓ enough (cat used ≤2 times). Abstract/concrete keywords per cat — write succinct. Vocab bank structure: (tier, word, k2, k1). Write both banks (16 entries each). Also note in key these are guides, examiner judgment applies. Information bank: (tier, question, answer). Answers as strings; key prints them. Now write out everything as final code. I'll be careful with f-strings containing unicode — fine. One more check — print_test digit span: iterate items sequentially printing kind headers on change ✓: ```python cur = None for t in data["items"]: if t["kind"] != cur: cur = t["kind"]; print(f"\n {SPAN_TITLE[cur]}"); print(f" {SPAN_INSTR[cur]}") print(f" {' '.join(map(str, t['seq']))}") ``` Where SPAN_TITLE = {"forward": "FORWARD — repeat in the same order", ...}. For self-testing note: "(cover after ~1 s per digit)". Console blank answers: instruct examinee writes on paper. Also add at top of each print: examiner guidance to administer aloud. Key JSON includes digit answers ✓ (scoring by examiner on paper). Now — final code writing. I'll also count roughly: this will be ~550-650 lines. Acceptable. Let me also decide symbol "▢" vs "_" for coding blanks: "▢" nicer; keep. Write LABELS: ```python LABELS = {"vocabulary": "Vocabulary", "similarities": "Similarities", "information": "Information", "block_design": "Block Design", "matrix_reasoning": "Matrix Reasoning", "visual_puzzles": "Visual Puzzles", "figure_weights": "Figure Weights", "digit_span": "Digit Span", "arithmetic": "Arithmetic", "letter_number": "Letter–Number Sequencing", "coding": "Coding", "symbol_search": "Symbol Search"} ``` SUBTEST_META = {sub: (LABELS[sub], idx, instruction, raw_def)} — idx per scale? vocabulary idx differs? Both scales VCI ✓; block_design PRI ✓; same idx both scales ✓ good. raw defs: - vocabulary: "Σ points (0–2 per word)" - similarities: "Σ points (0–2 per pair)" - information: "correct answers" - block_design: "correct items" - matrix_reasoning: "correct items" - visual_puzzles: "correct items" - figure_weights: "correct items" - digit_span: "correct trials (both directions; stop condition per instructions)" - arithmetic: "correct answers" - letter_number: "correct trials" - coding: "symbols correct in 120 s" - symbol_search: "correct − incorrect" NORMS as dict of dicts. Also in score mode, print subtest labels with idx groupings ✓. Potential math check: percentile for z=0 → 50.0 ✓. Scaled clamp: min 1 max 19 ✓. Index clamp 40-160; FSIQ clamp 40-160. classify boundaries: WAIS uses ≤69 Extremely Low ✓. I think we're ready to write. Also final docs section in response: **Usage:** ``` pip install nothing — stdlib only. Python 3.8+. python iqgen.py gen --scale wais --seed 7 --name "Jane Doe" python iqgen.py gen --scale wisc --seed 7 --name "Kid" python iqgen.py score --scale wais ``` Outputs: console test, `*_test.html` (printable, includes examiner key), `*_key.json`. **Scoring pipeline**: raw → z (calibration norms in NORMS) → scaled (M10/SD3) → indices (M100/SD15, mean of z) → FSIQ (mean of index z) → percentile/classification. Editable calibration. **Honest limitations** paragraph: - Original analog items, not real Wechsler items (copyrighted). - Real tests: auditory span, physical blocks, trained examiner, proprietary norms, discontinue rules, speed bonuses, alternate forms. - Self-administration inflates scores (esp. digit span seen in print, untimed items). - WISC-V actually splits PRI into VSI+FRI (5 indices) — this generator uses the 4-index structure; figure weights covers fluid reasoning flavor. - Not for diagnosis. Also maybe suggest: to make it auditory, have someone read; TTS; etc. Let me write the final code in the answer now. I'll assemble it with care, mentally compiling as I go. Actually — one more design decision: the user asked for "an entire WAIS and WISC FSIQ tests generators". I'm delivering one script with both. I'll state that clearly ("both generators in one file; each scale produces its own complete battery"). Good. Also double-check the HTML_KEY part — I'll write key_html generating tables: ```python def key_html(T): S = T["subtests"]; out = [] def h(name): out.append(f"

{name}

") h("Vocabulary"); table rows: word | 2-pt keywords | 1-pt keywords h("Similarities"); pair | 2 | 1 info: q | a arithmetic: q | a digit span: kind | digits | expected lns: seq | expected block: item | answer letter (plus grid? letters suffice) matrix: item | letter puzzles: letter; weights: letter coding: chunk rows with symbols symbol search: row | Y/N ``` Keep tables compact. For coding key: show digit/symbol rows in key. Time to write the answer. Let me carefully produce the code, watching for syntax errors, since it's long. Some final code-writing decisions to reduce bugs: - Avoid walrus/format complexities. - Use straightforward loops. - Test mentally tricky spots: f-string with nested quotes: use single-double mixes carefully (Python 3.8+ f-strings can't reuse same quote type inside; I'll use double quotes outside and single inside or escape). I'll standardize: f-strings with double quotes outside, single-quoted inside. For `grids_side_by_side` indentation: pass indent parameter default " ". Also matrix_console uses ljust(3)? counts up to 4 glyphs (distractors in options line not padded grid) — grid cells ≤ 3 glyphs; pad 4 for spacing: `.ljust(4)` then join " " → fine. Options line no padding needed. Console for block design model: label "Model:" then rows indent. I'll write `grid_console(g)` returning list of strings with "█" "·" "?". Hmm wait — in visual puzzles display grid has None → "?" ✓ handled by grid_console via v is None check. grid_console: ```python def grid_console(g): rows = [] for r in g: s = "" for v in r: s += "█" if v == 1 else ("·" if v == 0 else "?") rows.append(s) return rows ``` Figure weights console: ```python print(f" {i}. Pick what balances the last scale.") for k, (l, r) in enumerate(it["scales"], 1): print(f" Scale {k}: {combo_str(l)} ⚖ {combo_str(r)}") print(" " + " ".join(f"{LETTERS[j]}) {combo_str(o)}" for j, o in enumerate(it["options"]))) ``` combo_str(None) → "?" ✓. Wait scale tuple right None: combo_str handles None ✓. Let me also handle weights values note in key: answer letter + explanation? Key: answer letter; plus "values: ●=2 ■=3 ▲=4" hidden values for examiner verification — include values in key ✓. Digit span console grouping with stop-rule note ✓. Coding console chunks of 10 ✓; key console not printed (in JSON/HTML) — but print pointer note. Actually let me ALSO print the coding key in console key section? Console prints test only; key in files. Note at end: "Key saved to file." ✓. Now scoring input: also allow reading raws from a JSON file? Skip — interactive only, keeps smaller. Hmm, but examiners may want to score later... interactive is fine. Alright — also `IDX_FULL` and ORDER defined before use. Edge: WISC vocab uses WISC_VOCAB; WAIS uses WAIS_VOCAB ✓. Writing information banks — make sure answers concise. Also for the HTML `` empty answer cells ✓. One risk: huge HTML — fine. Also in print_test, before PSI section maybe blank line. Fine. Time to write it all out. I'll produce the response now: intro (short), battery table, code, usage, scoring explanation, limitations. Keep markdown headers, code block with python. The code will be long — that's the deliverable. Let me write the code text now in final form, section by section, double-checking syntax as I go. Section: constants & meta ```python LETTERS = "ABCDE" SHAPES = ["circle", "square", "triangle"] GLYPH = {("circle", True): "●", ("circle", False): "○", ("square", True): "■", ("square", False): "□", ("triangle", True): "▲", ("triangle", False): "△"} SYM_POOL = ["▲", "■", "●", "◆", "★", "✚", "◐", "♥", "▼", "◇", "□", "○", "♪", "✿"] IDX_FULL = {"VCI": "Verbal Comprehension", "PRI": "Perceptual Reasoning", "WMI": "Working Memory", "PSI": "Processing Speed"} LABELS = {...} SUBTEST_META = { "vocabulary": ("Ask “What does ___ mean?” ~30 s per word. Score 0/1/2 using the key. Stop after 4 consecutive 0s.", "Σ points (0–2 per word)"), ... } ``` Store as (instruction, raw_def). ORDER dict per scale. BATTERY dict per scale (idx → subs). NORMS dict. Then item banks, then generators, renderers, scoring, CLI. Careful with smart quotes in strings — fine in UTF-8, but keep ASCII quotes inside code strings to avoid terminal/font issues; use plain quotes. I'll use regular double quotes and avoid curly quotes entirely in code. Let me now also finalize WAIS_VOCAB & WISC_VOCAB entries (tier, word, k2 list, k1 list): WAIS: (1, "repair", ["fix", "mend", "restore", "make work again"], ["broken", "tool"]) (1, "cautious", ["careful", "avoiding risk or danger"], ["slow", "watchful", "thinking first"]) (1, "consume", ["use up", "eat or drink"], ["take", "finish"]) (1, "obedient", ["doing what one is told", "following rules or authority"], ["good", "listens"]) (2, "audible", ["able to be heard", "loud enough to hear"], ["sound", "not silent"]) (2, "reluctant", ["unwilling", "hesitant"], ["doesn't want to", "slow"]) (2, "elaborate", ["detailed", "intricate", "carefully developed"], ["fancy", "big", "lots of parts"]) (2, "fortify", ["strengthen", "reinforce", "defend"], ["build up", "protect"]) (3, "taciturn", ["habitually silent", "uncommunicative"], ["quiet", "doesn't talk"]) (3, "specious", ["seemingly right but actually false"], ["fake", "misleading"]) (3, "penurious", ["extremely poor", "miserly"], ["stingy", "cheap"]) (3, "fortuitous", ["happening by chance", "lucky"], ["unexpected", "by accident"]) (4, "perspicacious", ["having keen insight or judgment", "perceptive"], ["smart", "sharp"]) (4, "sanctimonious", ["pretending moral superiority", "hypocritically pious"], ["judgmental", "acting holy"]) (4, "vituperative", ["harsh or abusive in criticism"], ["mean", "insulting"]) (4, "quotidian", ["occurring every day", "ordinary"], ["common", "routine"]) WISC: (1, "ball", ["round object used in games", "toy you throw or kick"], ["round", "play", "bounce"]) (1, "book", ["bound pages with words to read"], ["read", "story", "pages"]) (1, "shoe", ["covering worn on the foot"], ["foot", "wear", "walk"]) (1, "night", ["dark part of the day", "time when we sleep"], ["dark", "sleep", "moon"]) (2, "brave", ["not afraid", "showing courage"], ["strong", "facing scary things"]) (2, "repair", ["fix", "mend"], ["broken", "make it work"]) (2, "enormous", ["very large", "huge"], ["big", "giant"]) (2, "ancient", ["very old", "from long ago"], ["old", "history"]) (3, "conceal", ["hide", "keep from being seen"], ["cover", "secret"]) (3, "abundant", ["plentiful", "existing in large quantity"], ["lots", "many"]) (3, "cautious", ["careful", "avoiding danger"], ["careful", "watch out"]) (3, "resemble", ["look like", "be similar to"], ["same", "alike"]) (4, "audible", ["able to be heard"], ["hear", "sound"]) (4, "tranquil", ["calm", "peaceful"], ["quiet", "still"]) (4, "demolish", ["destroy completely", "tear down"], ["break", "knock down"]) (4, "sluggish", ["slow-moving", "not active"], ["slow", "lazy", "tired"]) Note "repair"/"cautious"/"audible" overlap between banks — fine (different difficulty placement)? Duplicate across scales OK but within-bank distinct ✓. Hmm "audible" WISC t4 vs WAIS t2 — inconsistent difficulty, but they're separate batteries; acceptable. Eh, minor. Keep. INFO banks as above. Now, gen for similarities uses cat tuples (name, tier, abstract, concrete, items). Check: pool for WISC tiers 1-3 → cats count = 2+3+4 = 9 ✓; WAIS tiers 2-4 = 3+4+3 = 10 ✓. Now writing the full script text. Also remember Python needs the `math` import for erf ✓. Potential issue: `rng.shuffle(tier_words)` where tier_words is list of tuples ✓ fine. For vocab console `ljust(14)` — fine. Also print answer blanks? Console: examiner reads aloud; examinee answers verbally. Add note "(verbal response)". OK writing everything. For the HTML, I'll write subtest_html(sub, data) with branches. Also key_html(T). For matrix HTML: `

{i}. {matrix_svg}
{options_svg}
Answer:

`. Block HTML: model svg + options svgs inline with letters: options as row: for each option: `

{letter})
{grid_svg(opt)}

` — need svg width alignment; fine. Visual puzzle HTML: display grid + options like block. Weights HTML: weights_svg + options combo strings with letters: `

Options: A) ●■■ B) ...

` — use combo glyphs in text ✓ (unicode fine in HTML). Coding/SS/DS/Info/Arith/Vocab/Similarities HTML straightforward. Key HTML tables per subtest. Also I realize for digit_span trials the answer includes the sequence — key table: kind | digits | expected. LNS key: seq | expected. Also — scoring note for digit span discontinue: "stop a condition after both trials of the same length fail" — include in instructions ✓. Now — writing final. I must keep the response manageable; the code will dominate. Let me finalize and write, being disciplined about correctness over commentary. Actually, let me reconsider one more time whether to include BOTH the console printer AND HTML renderer AND scorer AND all banks in one reply. Estimate ~600-700 lines code. It's long but the user asked for "entire" generators (both scales, all 4 parts). I'll go for it, with terse prose around it. To trim: - HTML: I could make it more compact via shared helpers. - Keep instructions strings short. Also the response formatting: use a few headers, one battery table, the big code block, usage, scoring notes, limitations. Good. Final check on scoring formulas: FSIQ from mean of index z's — equivalent to mean of subtest z's here (each index same # subs? WAIS: VCI 3, PRI 3, WMI 2, PSI 2 → index means weight subtests unequally — fine, that's the intended "index first" approach, matches real practice conceptually (indices then FSIQ)). Let me write the score report to also save JSON report file: report_{scale}.json ✓ nice touch. Alright, compose everything now. def print_test ends with scoring cheat sheet: ```python print("\n" + hr("─")) print(" RAW SCORES -> run: python iqgen.py score --scale " + scale) for idx, sub in ORDER[scale]: ins, rawdef = SUBTEST_META[sub] print(f" {LABELS[sub]:<24} {rawdef}") ``` Wait SUBTEST_META values: I said (instruction, raw_def) — display name from LABELS ✓. In score_mode, show rawdef when prompting too — helpful ✓. Also digit span key: include both trials' expected — key lists all trials with answers ✓. Coding key JSON: digits + symbols lists ✓. HTML key for coding: maybe skip table (100 rows) — print digit/symbol pairs compactly: rows of 10 in key: digits row + symbols row. OK do chunks like console. Let me write code now. (Writing final code carefully…) ```python #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ iqgen.py - WAIS-style & WISC-style FSIQ practice-battery generators. One script, two complete generators (all four FSIQ domains each), original items only (real Wechsler items are copyrighted - these are analogs): WAIS-style (16+ yrs) WISC-style (6-16 yrs) ------------------------------------------------------------ VCI Vocabulary Similarities Info VCI Vocabulary Similarities PRI Block Design Matrix Reasoning | PRI Block Design Matrix Reasoning Visual Puzzles (Paper analogs) Figure Weights WMI Digit Span Arithmetic WMI Digit Span Letter-Number Seq. PSI Coding Symbol Search PSI Coding Symbol Search Commands python iqgen.py gen --scale wais --seed 7 --name "Jane" python iqgen.py gen --scale wisc --seed 7 --name "Sam" python iqgen.py score --scale wais (enter raw scores -> full report) Outputs (gen): console test, printable HTML with embedded SVG (+ examiner key), and a JSON key. Standard library only; Python 3.8+; run in a UTF-8 terminal. Educational practice tool. NOT a clinical instrument: norms below are editable approximations, several subtests are paper/console analogs, and self-testing distorts results (Digit Span should be auditory, Coding/Symbol Search strictly timed, verbal answers judged by an examiner). """ ``` Then code. I'll now write out the entire thing in the response. Let me make sure of a few more implementation details as I write: - `def generate(...)`: matrix small: `small = (scale == "wisc")` and tier ≤2. - arithmetic tiers for WAIS: `1 + i // 4`. - LNS only WISC. - coding digits count: 100/80. In print_test for WISC, no information/arithmetic/visual_puzzles; loop over ORDER ✓. In score_mode, iterate BATTERY[scale] ✓ (skip absent subs naturally). One more: json key includes "norms" — good for transparency. For percentile display of subtest scaled? Not needed. Report file: after computing, dump {"raws":..., "scaled":..., "indices":..., "fsiq":...} to report_{scale}.json ✓. Edge in score_mode: symbol_search raw can be negative → lo = -spec["max"] ✓. Check `input()` loop robust to EOF? If stdin closes → ValueError/EOFError crash — acceptable. Also `--no-html` flag ✓. Now, HTML: assemble `subtest_html(sub, data)` — implement branches: ```python def subtest_html(sub, data): if sub == "vocabulary": return "".join(f'

{i}. {html_escape(w)} —

' for i, (t, w, k2, k1) in enumerate(data["items"], 1)) if sub == "similarities": return "".join(f'

{i}. How are {a} and {b} alike?

' for i, p in enumerate(data["items"], 1) for a, b in [p["pair"]]) ``` Careful with the `for a, b in [p["pair"]]` trick — works but obscure; write normal loops with helper functions instead. I'll define small helper functions returning strings, then join. Write clean: ```python if sub == "similarities": out = [] for i, p in enumerate(data["items"], 1): a, b = p["pair"] out.append(f'

{i}. How are {a} and {b} alike?

') return "".join(out) ``` etc. Fine. digit_span_html: group by kind: ```python def digit_span_html(data): out = [] for kind, note in (("forward", "Repeat in the same order."), ("backward", "Repeat in reverse order."), ("sequencing", "Repeat lowest to highest.")): out.append(f"

{kind.title()}: {note} Examiner reads ~1 digit/second; examinee answers aloud. 2 trials per length; stop this condition after both trials of a length fail.

") out.append("") for t in [x for x in data["items"] if x["kind"] == kind]: out.append(f"") out.append("

Len	Digits (examiner only)
{t['len']}	{' '.join(map(str, t['seq']))}

") return "".join(out) ``` Since ORDER lists digit_span once, header h3 covers it. block_design_html: ```python out = [] for i, it in enumerate(data["items"], 1): opts = "".join(f'

{LETTERS[j]})
{grid_svg(o)}

' for j, o in enumerate(it["options"])) out.append(f'

{i}. Model (find the same design rotated, {it["limit_s"]} s):' f'

{grid_svg(it["model"])}

{opts}' f'
Answer:

') ``` matrix_html: ```python out.append(f'

{i}. {matrix_svg(it)}
{options_svg(it["options"])}
Answer:

') ``` visual_puzzles_html: like block with display grid + options. figure_weights_html: ```python out.append(f'

{i}. {weights_svg(it)}
Options: ' + " ".join(f"{LETTERS[j]}) {combo_str(o)}" for j, o in enumerate(it["options"])) + '
Answer:

') ``` coding_html as planned. symbol_search_html as planned. key_html(T): build tables: vocab: rows word | 2-pt | 1-pt. similarities: pair | 2-pt | 1-pt. info: # | question | answer. arithmetic: # | question | answer. digit_span: kind | digits | expected. lns: sequence | expected. block/matrix/puzzles/weights: # | correct letter (+ weights hidden values). coding: chunks digits+symbols. symbol_search: # | Y/N. OK. Writing the final response now. Also include at top-of-reply: quick summary + battery mapping table + disclaimers; then code; then usage & scoring & limitations. Let me draft the final code completely (this is the critical part — I'll write it as I would in an editor, keeping consistent): ```python import argparse, datetime, json, math, random, sys LETTERS = "ABCDE" SHAPES = ["circle", "square", "triangle"] GLYPH = {("circle", True): "●", ("circle", False): "○", ("square", True): "■", ("square", False): "□", ("triangle", True): "▲", ("triangle", False): "△"} SYM_POOL = ["▲", "■", "●", "◆", "★", "✚", "◐", "♥", "▼", "◇", "□", "○", "♪", "✿"] IDX_FULL = {"VCI": "Verbal Comprehension", "PRI": "Perceptual Reasoning", "WMI": "Working Memory", "PSI": "Processing Speed"} LABELS = { "vocabulary": "Vocabulary", "similarities": "Similarities", "information": "Information", "block_design": "Block Design", "matrix_reasoning": "Matrix Reasoning", "visual_puzzles": "Visual Puzzles", "figure_weights": "Figure Weights", "digit_span": "Digit Span", "arithmetic": "Arithmetic", "letter_number": "Letter-Number Seq.", "coding": "Coding", "symbol_search": "Symbol Search"} SUBTEST_META = { # subtest -> (examiner instruction, raw-score definition) "vocabulary": ('Ask "What does ___ mean

Create me an entire WAIS and WISC FSIQ tests generators each...