Upload folder using huggingface_hub

.gitattributes

@@ -1,5 +1,6 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text
@@ -8,6 +9,8 @@
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +36,27 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+Data/Math_Standards1.pdf filter=lfs diff=lfs merge=lfs -text

Code/LICENSE

@@ -0,0 +1,40 @@
+Creative Commons Attribution-NonCommercial 4.0 International License (CC BY-NC 4.0)
+
+Copyright (c) 2024 FoundationalED Authors
+
+You are free to:
+
+  Share — copy and redistribute the material in any medium or format
+
+  Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+
+  Attribution — You must give appropriate credit, provide a link to the license,
+  and indicate if changes were made. You may do so in any reasonable manner, but
+  not in any way that suggests the licensor endorses you or your use.
+
+  NonCommercial — You may not use the material for commercial purposes.
+
+  No additional restrictions — You may not apply legal terms or technological
+  measures that legally restrict others from doing anything the license permits.
+
+Notices:
+
+  You do not have to comply with the license for elements of the material in
+  the public domain or where your use is permitted by an applicable exception
+  or limitation.
+
+  No warranties are given. The license may not give you all of the permissions
+  necessary for your intended use. For example, other rights such as publicity,
+  privacy, or moral rights may limit how you use the material.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode
+
+================================================================================
+
+ADDITIONAL TERMS FOR FOUNDATIONALED DATASET
+
+By accessing or using the FoundationalED dataset, you additionally agree to the
+Data Usage Agreement specified in the README.md file, which includes restrictions
+on re-identification, ethical use requirements, and compliance obligations.

Code/build_skill_set.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Build Skill_List.csv from Skills.csv and CASE Common Core standards JSON.
+
+Output columns:
+- index (1-based)
+- skill_code
+- full_description
+
+The output contains only skill codes that appear in both:
+1) Skills.csv (column: node_code)
+2) CASE JSON CFItems (field: humanCodingScheme)
+
+Rows are sorted by skill_code.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import html
+import json
+import re
+from pathlib import Path
+from typing import Dict, Set
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+_DOT_BEFORE_SUFFIX_RE = re.compile(r"(?<=\d)\.(?=[A-Za-z]$)")
+
+
+def _clean_text(text: str) -> str:
+    """Normalize whitespace and strip simple HTML tags from a description."""
+    text = html.unescape(text or "")
+    text = _TAG_RE.sub("", text)
+    text = _WS_RE.sub(" ", text).strip()
+    return text
+
+
+def _normalize_skill_code(code: str) -> str:
+    """Normalize equivalent skill code formats to a common representation.
+
+    Example:
+    - 3.MD.C.7a  -> 3.MD.C.7a
+    - 3.MD.C.7.a -> 3.MD.C.7a
+    """
+    normalized = (code or "").strip()
+    normalized = _DOT_BEFORE_SUFFIX_RE.sub("", normalized)
+    return normalized
+
+
+def load_skill_codes(skills_csv_path: Path) -> Set[str]:
+    """Read unique skill codes from Skills.csv node_code column."""
+    codes: Set[str] = set()
+    with skills_csv_path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        if "node_code" not in (reader.fieldnames or []):
+            raise ValueError(
+                f"Missing required column 'node_code' in {skills_csv_path}"
+            )
+        for row in reader:
+            code = (row.get("node_code") or "").strip()
+            if code:
+                codes.add(code)
+    return codes
+
+
+def load_case_mapping(case_json_path: Path) -> Dict[str, str]:
+    """Map skill code -> full standard statement from CASE JSON CFItems."""
+    with case_json_path.open("r", encoding="utf-8") as f:
+        payload = json.load(f)
+
+    mapping: Dict[str, str] = {}
+    for item in payload.get("CFItems", []):
+        raw_code = (item.get("humanCodingScheme") or "").strip()
+        code = _normalize_skill_code(raw_code)
+        if not code:
+            continue
+
+        # Keep both Standards and Components.
+        # In CASE, codes like 3.MD.C.7.a are often CFItemType=Component.
+        if item.get("CFItemType") not in {"Standard", "Component"}:
+            continue
+
+        statement = _clean_text(item.get("fullStatement") or "")
+        if not statement:
+            continue
+
+        # Keep first non-empty definition if duplicates appear.
+        if code not in mapping:
+            mapping[code] = statement
+
+    return mapping
+
+
+def write_output(output_csv_path: Path, rows: list[tuple[str, str]]) -> None:
+    """Write final CSV with a 1-based index."""
+    output_csv_path.parent.mkdir(parents=True, exist_ok=True)
+    with output_csv_path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["index", "skill_code", "full_description"])
+        for idx, (code, desc) in enumerate(rows, start=1):
+            writer.writerow([idx, code, desc])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Create Skill_List.csv from Skills.csv and CASE standards JSON."
+    )
+    parser.add_argument(
+        "--skills-csv",
+        type=Path,
+        default=Path("../Data/Skills.csv"),
+        help="Path to Skills.csv",
+    )
+    parser.add_argument(
+        "--case-json",
+        type=Path,
+        default=Path("../Data/CASE-Common Core State Standards for Math.json"),
+        help="Path to CASE JSON",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("../Data/Skill_Set.csv"),
+        help="Output path for Skill_Set.csv",
+    )
+
+    args = parser.parse_args()
+
+    skills_csv = args.skills_csv.resolve()
+    case_json = args.case_json.resolve()
+    output_csv = args.output_csv.resolve()
+
+    skill_codes = load_skill_codes(skills_csv)
+    case_map = load_case_mapping(case_json)
+
+    matched_codes = sorted(
+        code for code in skill_codes if _normalize_skill_code(code) in case_map
+    )
+    rows = [(code, case_map[_normalize_skill_code(code)]) for code in matched_codes]
+
+    write_output(output_csv, rows)
+
+    missing = sorted(
+        code for code in skill_codes if _normalize_skill_code(code) not in case_map
+    )
+    print(f"Wrote {len(rows)} skills to {output_csv}")
+    print(f"Unique skill codes in Skills.csv: {len(skill_codes)}")
+    print(f"Missing codes not found in CASE: {len(missing)}")
+    if missing:
+        preview = ", ".join(missing[:20])
+        suffix = " ..." if len(missing) > 20 else ""
+        print(f"Missing preview: {preview}{suffix}")
+
+
+if __name__ == "__main__":
+    main()

Code/clean_utils.py

@@ -0,0 +1,148 @@
+"""
+HTML cleaning utilities for problem text.
+
+Provides functions to clean HTML content while preserving:
+- Inline MathML (fractions, superscripts, subscripts)
+- Wiris math images (extracted from data-mathml attribute)
+- Table structure (formatted with | separators)
+- Image placeholders
+"""
+
+import html
+import pandas as pd
+from bs4 import BeautifulSoup, NavigableString
+
+
+def parse_mathml_element(elem):
+    """Recursively parse a MathML element to text."""
+    if elem.name is None:
+        return str(elem).strip()
+
+    if elem.name == "mfrac":
+        children = [c for c in elem.children if c.name]
+        if len(children) >= 2:
+            num = parse_mathml_element(children[0])
+            denom = parse_mathml_element(children[1])
+            return f"({num}/{denom})"
+        return elem.get_text(strip=True)
+
+    elif elem.name == "msup":
+        children = [c for c in elem.children if c.name]
+        if len(children) >= 2:
+            base = parse_mathml_element(children[0])
+            exp = parse_mathml_element(children[1])
+            return f"{base}^{exp}"
+        return elem.get_text(strip=True)
+
+    elif elem.name == "msub":
+        children = [c for c in elem.children if c.name]
+        if len(children) >= 2:
+            base = parse_mathml_element(children[0])
+            sub = parse_mathml_element(children[1])
+            return f"{base}_{sub}"
+        return elem.get_text(strip=True)
+
+    elif elem.name == "msqrt":
+        content = parse_mathml_element_children(elem)
+        return f"√({content})"
+
+    elif elem.name == "mo":
+        op = elem.get_text(strip=True)
+        if op in ["÷", "×", "·", "+", "-", "=", "<", ">", "≤", "≥", "≠"]:
+            return f" {op} "
+        return op
+
+    elif elem.name in ["mn", "mi", "mtext"]:
+        return elem.get_text(strip=True)
+
+    elif elem.name in ["mrow", "math", "mpadded", "mstyle"]:
+        return parse_mathml_element_children(elem)
+
+    else:
+        return elem.get_text(strip=True)
+
+
+def parse_mathml_element_children(elem):
+    """Parse all children of a MathML element."""
+    parts = []
+    for child in elem.children:
+        if isinstance(child, NavigableString):
+            text = str(child).strip()
+            if text:
+                parts.append(text)
+        elif child.name:
+            parts.append(parse_mathml_element(child))
+    return "".join(parts)
+
+
+def clean_problem_body(text):
+    """
+    Clean HTML problem body with full MathML handling.
+
+    Handles:
+    - Inline MathML (<math>, <mfrac>, <msup>, etc.) → (4/3), x^2
+    - Wiris math images (data-mathml attribute) → [15÷12]
+    - Tables → [Table: Col1 | Col2 ...]
+    - Regular images → [image]
+    - HTML entities → decoded properly
+    """
+    if pd.isna(text) or text == "":
+        return ""
+    soup = BeautifulSoup(str(text), "html.parser")
+
+    # 1. Handle inline MathML
+    for math in soup.find_all("math"):
+        parsed = parse_mathml_element(math)
+        math.replace_with(f" {parsed} ")
+
+    # 2. Handle Wiris images
+    for img in soup.find_all("img"):
+        alt = img.get("alt", "")
+        src = img.get("src", "")
+        data_mathml = img.get("data-mathml", "")
+
+        if "wiris" in src.lower() or "pluginwiris" in src:
+            if alt and alt.strip() and alt not in ["NO ALT", "NONE"]:
+                img.replace_with(f" [{alt.strip()}] ")
+            elif data_mathml:
+                math_str = (
+                    data_mathml.replace("«", "<").replace("»", ">").replace("¨", '"')
+                )
+                msoup = BeautifulSoup(math_str, "html.parser")
+                math_elem = msoup.find("math")
+                if math_elem:
+                    mtext = parse_mathml_element(math_elem)
+                else:
+                    mtext = msoup.get_text(separator="")
+                mtext = mtext.replace("§#247;", "÷").replace("§#215;", "×")
+                mtext = (
+                    mtext.replace("§#8722;", "-")
+                    .replace("§#160;", " ")
+                    .replace("§#183;", "·")
+                )
+                mtext = mtext.replace("§#", "&#")
+                mtext = html.unescape(mtext).strip()
+                img.replace_with(f" [{mtext}] " if mtext else " [math] ")
+            else:
+                img.replace_with(" [math] ")
+        elif alt and alt.strip():
+            img.replace_with(f" [Image: {alt.strip()[:100]}] ")
+        else:
+            img.replace_with(" [image] ")
+
+    # 3. Handle tables
+    for table in soup.find_all("table"):
+        rows = []
+        for tr in table.find_all("tr"):
+            cells = [td.get_text(strip=True) for td in tr.find_all(["td", "th"])]
+            if any(cells):
+                rows.append(" | ".join(cells))
+        if rows:
+            table.replace_with(f"\n[Table:\n{chr(10).join(rows)}]\n")
+        else:
+            table.decompose()
+
+    text = soup.get_text(separator=" ")
+    text = html.unescape(text)
+    text = " ".join(text.split())
+    return text.strip()

Code/cleantext.py

@@ -0,0 +1,102 @@
+import pandas as pd
+
+def add_pi_if_missing(input_string):
+    # Check if "se 3.14 for" is in the input string
+    if "se 3.14 for" in input_string:
+        # Check if "pi" is not already present after "se 3.14 for"
+        if "pi" not in input_string[input_string.index("se 3.14 for") + len("se 3.14 for"):]:
+            return input_string[:input_string.index("se 3.14 for") + len("se 3.14 for")] + " pi" + input_string[input_string.index("se 3.14 for") + len("se 3.14 for"):]
+    return input_string
+
+def convert_mathml_to_fraction(mathml_content):
+    mathml_content = mathml_content.replace('<ast-r type="text" marker="1">', "___")
+    mathml_content = mathml_content.replace('<mfrac>', '(')
+    mathml_content = mathml_content.replace('</mfrac>', ')')
+    mathml_content = mathml_content.replace('</mn><mn>', '/')
+    mathml_content = mathml_content.replace('<mn>', '')
+    mathml_content = mathml_content.replace('</mn>', '')
+    mathml_content = mathml_content.replace('<mi>', '')
+    mathml_content = mathml_content.replace('</mi>', '')
+    mathml_content = mathml_content.replace('<mo>', '')
+    mathml_content = mathml_content.replace('</mo>', '')
+    mathml_content = mathml_content.replace('<mn>', '')
+    mathml_content = mathml_content.replace('</mn>', '')
+    mathml_content = mathml_content.replace('<math>', '')
+    mathml_content = mathml_content.replace('</math>', '')
+    mathml_content = mathml_content.replace('<mi mathvariant=¨normal¨>§#960;', '')
+    mathml_content = mathml_content.replace('&nbsp;', ' ')
+    mathml_content = mathml_content.replace('§#160;', ' ')
+    mathml_content = mathml_content.replace('&gt;', '>')
+    mathml_content = mathml_content.replace('&lt;', '<')
+    mathml_content = mathml_content.replace('&amp;', '&')
+    
+    mathml_content = mathml_content.replace('«/math', '')
+
+    mathml_content = mathml_content.rstrip('/')
+    
+    return mathml_content
+
+
+from bs4 import BeautifulSoup
+def alt_text(html: str) -> str:
+    soup = BeautifulSoup(html, 'html.parser')
+    
+    # Replace each <img> with its alt text if it exists
+    for img in soup.find_all('img'):
+        alt = img.get('alt')
+        if alt:
+            img.replace_with(alt)
+    
+    return str(soup)
+
+def mathml_to_text(html):
+    soup = BeautifulSoup(html, 'html.parser')
+
+    # Convert MathML fractions
+    for math in soup.find_all('math'):
+        frac = math.find('mfrac')
+        if frac:
+            nums = frac.find_all('mn')
+            if len(nums) == 2:
+                numerator = nums[0].text
+                denominator = nums[1].text
+                frac_text = f"{numerator}/{denominator}"
+                math.replace_with(frac_text)
+            else:
+                math.replace_with(math.get_text())  # Fallback if not a valid mfrac
+        else:
+            math.replace_with(math.get_text())  # Handle non-fraction math
+
+    # Return clean text
+    return soup.get_text(separator=" ", strip=True)
+
+
+def clean_text(input_text):
+    if pd.isna(input_text) or input_text.strip() == "":
+        return ""
+
+    # Replace &nbsp; and decode HTML entities
+    input_text = input_text.replace('&nbsp;', ' ')
+    
+    # Replace <img> tags with their alt text
+    input_text = mathml_to_text(input_text)
+    input_text = alt_text(input_text)
+
+    # Convert MathML if it exists
+    soup = BeautifulSoup(input_text, 'html.parser')
+    for img in soup.find_all('img', class_='Wirisformula'):
+        mathml_formula = img.get('data-mathml')
+        if mathml_formula:
+            # Extract inner MathML content
+            start_index = mathml_formula.find('<math>') + len('<math>')
+            end_index = mathml_formula.find('</math>')
+            mathml_formula_content = mathml_formula[start_index:end_index]
+            mathml_formula_content_cleaned = mathml_formula_content.replace(
+                'xmlns=¨http://www.w3.org/1998/Math/MathML¨»', '')
+            fraction = convert_mathml_to_fraction(mathml_formula_content_cleaned)
+            img.replace_with(fraction)
+
+    text = soup.get_text(separator=' ', strip=True)
+    text = convert_mathml_to_fraction(text)
+    text = add_pi_if_missing(text)
+    return text

Code/detect_similar_node_codes.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""Detect skills that have similar node_code values but different skill_id values.
+
+By default, the script detects conflicts after normalizing node_code values
+(uppercasing and removing punctuation differences). It can also perform optional
+fuzzy matching on normalized compact node codes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+from difflib import SequenceMatcher
+from itertools import combinations
+from pathlib import Path
+
+import pandas as pd
+
+
+DEFAULT_SKILLS_PATH = Path(__file__).resolve().parent.parent / "Data" / "Skills.csv"
+DEFAULT_OUTPUT_PATH = (
+    Path(__file__).resolve().parent.parent
+    / "Results"
+    / "similar_node_code_conflicts.csv"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Detect skills whose node_code values are similar but map to "
+            "different skill_id values."
+        )
+    )
+    parser.add_argument(
+        "--skills-path",
+        type=Path,
+        default=DEFAULT_SKILLS_PATH,
+        help="Path to Skills.csv.",
+    )
+    parser.add_argument(
+        "--output-path",
+        type=Path,
+        default=DEFAULT_OUTPUT_PATH,
+        help="Path to save the detected conflicts as CSV.",
+    )
+    parser.add_argument(
+        "--include-fuzzy",
+        action="store_true",
+        help="Also run fuzzy matching across compact node_code values.",
+    )
+    parser.add_argument(
+        "--similarity-threshold",
+        type=float,
+        default=0.9,
+        help="Minimum SequenceMatcher ratio for fuzzy matches (0.0 to 1.0).",
+    )
+    parser.add_argument(
+        "--max-fuzzy-pairs",
+        type=int,
+        default=200,
+        help="Maximum number of fuzzy match pairs to keep after sorting.",
+    )
+    parser.add_argument(
+        "--print-limit",
+        type=int,
+        default=20,
+        help="Maximum number of rows to print for each conflict section.",
+    )
+    return parser.parse_args()
+
+
+def normalize_node_code(node_code: str) -> str:
+    canonical = re.sub(r"[^A-Za-z0-9]+", ".", node_code.upper().strip())
+    canonical = re.sub(r"\.+", ".", canonical).strip(".")
+    return canonical
+
+
+def compact_node_code(canonical_node_code: str) -> str:
+    return canonical_node_code.replace(".", "")
+
+
+def unique_sorted_strings(series: pd.Series) -> list[str]:
+    values: set[str] = set()
+    for value in series.dropna():
+        text = str(value).strip()
+        if text:
+            values.add(text)
+    return sorted(values)
+
+
+def unique_sorted_ints(series: pd.Series) -> list[int]:
+    values: set[int] = set()
+    for value in series.dropna():
+        values.add(int(value))
+    return sorted(values)
+
+
+def join_pipe(values: list[str]) -> str:
+    return " | ".join(values)
+
+
+def join_csv_ints(values: list[int]) -> str:
+    return ",".join(str(v) for v in values)
+
+
+def load_skills(skills_path: Path) -> pd.DataFrame:
+    required_columns = ["problem_id", "skill_id", "node_code", "node_name"]
+    df = pd.read_csv(skills_path, usecols=required_columns, low_memory=False)
+
+    df["problem_id"] = pd.to_numeric(df["problem_id"], errors="coerce")
+    df["skill_id"] = pd.to_numeric(df["skill_id"], errors="coerce")
+
+    df = df.dropna(subset=["problem_id", "skill_id", "node_code"]).copy()
+    df["problem_id"] = df["problem_id"].astype(int)
+    df["skill_id"] = df["skill_id"].astype(int)
+
+    df["node_code"] = df["node_code"].astype(str).str.strip()
+    df["node_name"] = df["node_name"].fillna("").astype(str).str.strip()
+    df = df[df["node_code"] != ""].copy()
+
+    df["node_code_canonical"] = df["node_code"].apply(normalize_node_code)
+    df["node_code_compact"] = df["node_code_canonical"].apply(compact_node_code)
+    return df
+
+
+def summarize_compact_codes(df: pd.DataFrame) -> pd.DataFrame:
+    summary = (
+        df.groupby("node_code_compact", sort=True)
+        .agg(
+            canonical_node_codes=("node_code_canonical", unique_sorted_strings),
+            raw_node_codes=("node_code", unique_sorted_strings),
+            skill_ids=("skill_id", unique_sorted_ints),
+            node_names=("node_name", unique_sorted_strings),
+            problem_count=("problem_id", "nunique"),
+            mapping_count=("skill_id", "size"),
+        )
+        .reset_index()
+        .rename(columns={"node_code_compact": "compact_node_code"})
+    )
+
+    summary["n_skill_ids"] = summary["skill_ids"].apply(len)
+    return summary
+
+
+def build_normalized_conflicts(summary: pd.DataFrame) -> pd.DataFrame:
+    conflicts = summary[summary["n_skill_ids"] > 1].copy()
+    if conflicts.empty:
+        return conflicts
+
+    conflicts.insert(0, "conflict_type", "normalized_match")
+    conflicts["skill_ids"] = conflicts["skill_ids"].apply(join_csv_ints)
+    conflicts["canonical_node_codes"] = conflicts["canonical_node_codes"].apply(
+        join_pipe
+    )
+    conflicts["raw_node_codes"] = conflicts["raw_node_codes"].apply(join_pipe)
+    conflicts["node_names"] = conflicts["node_names"].apply(join_pipe)
+
+    return conflicts.sort_values(
+        ["n_skill_ids", "compact_node_code"], ascending=[False, True]
+    )
+
+
+def build_fuzzy_conflicts(
+    summary: pd.DataFrame,
+    threshold: float,
+    max_pairs: int,
+) -> pd.DataFrame:
+    rows: list[dict[str, object]] = []
+
+    records = summary.to_dict(orient="records")
+    for left, right in combinations(records, 2):
+        left_code = str(left["compact_node_code"])
+        right_code = str(right["compact_node_code"])
+
+        if left_code == right_code:
+            continue
+
+        similarity = SequenceMatcher(None, left_code, right_code).ratio()
+        if similarity < threshold:
+            continue
+
+        left_skills = set(left["skill_ids"])
+        right_skills = set(right["skill_ids"])
+        if left_skills == right_skills:
+            continue
+
+        rows.append(
+            {
+                "conflict_type": "fuzzy_match",
+                "similarity": round(similarity, 4),
+                "left_compact_node_code": left_code,
+                "right_compact_node_code": right_code,
+                "left_canonical_node_codes": join_pipe(left["canonical_node_codes"]),
+                "right_canonical_node_codes": join_pipe(right["canonical_node_codes"]),
+                "left_skill_ids": join_csv_ints(left["skill_ids"]),
+                "right_skill_ids": join_csv_ints(right["skill_ids"]),
+                "overlap_skill_ids": join_csv_ints(
+                    sorted(left_skills.intersection(right_skills))
+                ),
+            }
+        )
+
+    fuzzy = pd.DataFrame(rows)
+    if fuzzy.empty:
+        return fuzzy
+
+    fuzzy = fuzzy.sort_values(
+        ["similarity", "left_compact_node_code", "right_compact_node_code"],
+        ascending=[False, True, True],
+    )
+    if max_pairs > 0:
+        fuzzy = fuzzy.head(max_pairs).copy()
+    return fuzzy
+
+
+def print_section(title: str, df: pd.DataFrame, print_limit: int) -> None:
+    print(f"\n{title}")
+    if df.empty:
+        print("  None")
+        return
+
+    to_show = df.head(print_limit)
+    print(to_show.to_string(index=False))
+    if len(df) > len(to_show):
+        print(f"  ... ({len(df) - len(to_show)} more rows)")
+
+
+def main() -> int:
+    args = parse_args()
+
+    if args.similarity_threshold < 0.0 or args.similarity_threshold > 1.0:
+        raise ValueError("--similarity-threshold must be in [0.0, 1.0].")
+
+    if not args.skills_path.exists():
+        raise FileNotFoundError(f"Skills file not found: {args.skills_path}")
+
+    skills_df = load_skills(args.skills_path)
+    summary_df = summarize_compact_codes(skills_df)
+
+    normalized_conflicts = build_normalized_conflicts(summary_df)
+    fuzzy_conflicts = pd.DataFrame()
+    if args.include_fuzzy:
+        fuzzy_conflicts = build_fuzzy_conflicts(
+            summary_df,
+            threshold=args.similarity_threshold,
+            max_pairs=args.max_fuzzy_pairs,
+        )
+
+    frames = [normalized_conflicts]
+    if args.include_fuzzy:
+        frames.append(fuzzy_conflicts)
+    combined_output = pd.concat(frames, ignore_index=True, sort=False)
+
+    args.output_path.parent.mkdir(parents=True, exist_ok=True)
+    combined_output.to_csv(args.output_path, index=False)
+
+    print("Loaded rows:", len(skills_df))
+    print("Unique compact node codes:", len(summary_df))
+    print("Normalized conflicts:", len(normalized_conflicts))
+    if args.include_fuzzy:
+        print(
+            "Fuzzy conflicts (threshold " f"{args.similarity_threshold:.2f}):",
+            len(fuzzy_conflicts),
+        )
+
+    print_section(
+        "Normalized node_code conflicts (same compact code, different skill_id):",
+        normalized_conflicts,
+        args.print_limit,
+    )
+
+    if args.include_fuzzy:
+        print_section(
+            "Fuzzy node_code conflicts (near compact codes, different skill_id):",
+            fuzzy_conflicts,
+            args.print_limit,
+        )
+
+    print(f"\nSaved conflicts to: {args.output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Code/evaluate_kt.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Evaluate LLM knowledge tracing predictions against FKT benchmark tasks.
+
+Tasks evaluated:
+  - Task 1 (FKT): Foundational Knowledge Tracing - predict if student answers correctly (question-level)
+  - Task 1 Variant 2: Cognitive Student Modeling - predict the actual student response
+
+Usage:
+    python evaluate_kt.py results.jsonl
+"""
+
+import argparse
+import json
+import math
+from sklearn.metrics import roc_auc_score
+
+
+def normalize_mcq_answer(answer_str: str) -> str:
+    """
+    Normalize MCQ answer format for consistent comparison.
+
+    Handles variations like:
+    - 'C, A' -> 'A, C' (order normalization)
+    - 'A,C' -> 'A, C' (spacing normalization)
+    - 'a, c' -> 'A, C' (case normalization)
+
+    Args:
+        answer_str: Answer string to normalize
+
+    Returns:
+        Normalized answer string, or original if not MCQ format
+    """
+    # Split by comma, strip whitespace, uppercase, sort, rejoin
+    parts = [p.strip().upper() for p in answer_str.split(',')]
+    # Filter out empty parts
+    parts = [p for p in parts if p]
+    # Only normalize if all parts are single letters (MCQ format)
+    if parts and all(len(p) == 1 and p.isalpha() for p in parts):
+        return ', '.join(sorted(set(parts)))
+    return answer_str
+
+
+def numerical_match(answer1: str, answer2: str, atol: float = 0.01, rtol: float = 0.01) -> bool:
+    """
+    Check if two answers are numerically close within tolerance.
+
+    Uses math.isclose for robust comparison that handles both absolute
+    and relative tolerance.
+
+    Args:
+        answer1: First answer string
+        answer2: Second answer string
+        atol: Absolute tolerance (default: 0.01)
+        rtol: Relative tolerance (default: 0.01)
+
+    Returns:
+        True if answers are numerically close, False otherwise
+    """
+    try:
+        a = float(answer1.strip())
+        b = float(answer2.strip())
+        return math.isclose(a, b, abs_tol=atol, rel_tol=rtol)
+    except (ValueError, AttributeError):
+        return False
+
+
+def answers_match(pred, actual):
+    """Check if predicted answer matches actual answer."""
+    if pred is None or actual is None:
+        return False
+
+    pred_str = str(pred).strip()
+    actual_str = str(actual).strip()
+
+    # Exact string match
+    if pred_str == actual_str:
+        return True
+
+    # Normalize MCQ answers (handles case, order, spacing)
+    pred_normalized = normalize_mcq_answer(pred_str)
+    actual_normalized = normalize_mcq_answer(actual_str)
+    if pred_normalized == actual_normalized:
+        return True
+
+    # Numeric match with tolerance
+    return numerical_match(pred_str, actual_str)
+
+
+def load_results(jsonl_path):
+    """Load results from JSONL file."""
+    results = []
+    with open(jsonl_path, 'r') as f:
+        for line in f:
+            if line.strip():
+                results.append(json.loads(line))
+    return results
+
+
+def evaluate(results):
+    """Compute evaluation metrics aligned with FKT benchmark tasks."""
+    total = len(results)
+
+    if total == 0:
+        print("No results to evaluate.")
+        return
+
+    # Compute class distribution
+    n_correct = sum(1 for r in results if r.get('actual_score') == 1)
+    n_incorrect = total - n_correct
+
+    # Task 1: FKT - Question-level accuracy
+    valid_q = [(r.get('actual_score'), r.get('predicted_question_level'))
+               for r in results
+               if r.get('actual_score') is not None and r.get('predicted_question_level') is not None]
+
+    if valid_q:
+        y_true, y_pred = zip(*valid_q)
+        question_correct = sum(1 for t, p in valid_q if t == p)
+        question_acc = question_correct / len(valid_q)
+        # AUC-ROC (note: with binary predictions, this is limited)
+        try:
+            auc_roc = roc_auc_score(y_true, y_pred)
+        except ValueError:
+            auc_roc = None  # Only one class present
+    else:
+        question_correct = 0
+        question_acc = 0.0
+        auc_roc = None
+
+    # Task 1 Variant 2: Cognitive Modeling - Answer prediction accuracy
+    answer_correct = sum(
+        1 for r in results
+        if answers_match(r.get('predicted_student_answer'), r.get('actual_answer'))
+    )
+
+    # Baselines
+    prior_baseline = 0.615  # True correctness rate from Interactions.csv
+    majority_baseline = max(n_correct, n_incorrect) / total
+
+    # Print results
+    print(f"{'='*60}")
+    print(f"Evaluation Results ({total} predictions)")
+    print(f"{'='*60}")
+    print()
+    print(f"Class distribution: {n_correct} correct, {n_incorrect} incorrect")
+    print()
+
+    # Task 1: Foundational Knowledge Tracing (FKT) - question-level prediction
+    print("Task 1: Foundational Knowledge Tracing (FKT) - Question-Level")
+    print(f"  Accuracy:  {question_correct}/{len(valid_q)} = {question_acc:.3f}")
+    if auc_roc is not None:
+        print(f"  AUC-ROC:   {auc_roc:.3f}")
+    else:
+        print(f"  AUC-ROC:   N/A (single class)")
+    print(f"  Baselines: Prior={prior_baseline:.3f}, Majority={majority_baseline:.3f}")
+    print()
+
+    # Task 1 Variant 2: Cognitive Student Modeling
+    print("Task 1 Variant 2: Cognitive Student Modeling")
+    print(f"  Overall Accuracy: {answer_correct}/{total} = {answer_correct/total:.3f}")
+
+    # Breakdown by problem type
+    problem_types = ['Multiple Choice (select 1)', 'Multiple Choice (select all)', 'Fill-in-the-blank(s)']
+    has_problem_type = any(r.get('problem_type') for r in results)
+    if has_problem_type:
+        print("  By problem type:")
+        for ptype in problem_types:
+            subset = [r for r in results if r.get('problem_type') == ptype]
+            if subset:
+                n = len(subset)
+                a_acc = sum(1 for r in subset if answers_match(r.get('predicted_student_answer'), r.get('actual_answer'))) / n
+                label = ptype.replace('Multiple Choice ', 'MC ')
+                print(f"    {label:20s}: n={n:4d}, acc={a_acc:.3f}")
+                # Breakdown by ground truth within problem type
+                for gt in ['correct', 'incorrect']:
+                    gt_subset = [r for r in subset if r.get('prediction_type') == gt]
+                    if gt_subset:
+                        gt_n = len(gt_subset)
+                        gt_acc = sum(1 for r in gt_subset if answers_match(r.get('predicted_student_answer'), r.get('actual_answer'))) / gt_n
+                        print(f"      {gt:18s}: n={gt_n:4d}, acc={gt_acc:.3f}")
+    print()
+
+    # Breakdown by prediction type (correct/incorrect ground truth)
+    print("By ground truth (prediction_type):")
+    for ptype in ['correct', 'incorrect']:
+        subset = [r for r in results if r.get('prediction_type') == ptype]
+        if subset:
+            n = len(subset)
+            q_acc = sum(1 for r in subset if r.get('predicted_question_level') == r.get('actual_score')) / n
+            a_acc = sum(1 for r in subset if answers_match(r.get('predicted_student_answer'), r.get('actual_answer'))) / n
+            print(f"  {ptype:10s}: n={n:4d}, FKT_acc={q_acc:.3f}, cognitive_acc={a_acc:.3f}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate LLM knowledge tracing predictions")
+    parser.add_argument("jsonl_file", help="Path to JSONL results file")
+    args = parser.parse_args()
+
+    results = load_results(args.jsonl_file)
+    evaluate(results)
+
+
+if __name__ == "__main__":
+    main()

Code/evaluate_kt_by_context.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+Evaluate KT performance by context length (history size).
+
+Analyzes how KT accuracy changes as student history grows from 50 to 400 interactions.
+Plots all models in a single figure for comparison.
+
+Usage:
+    python evaluate_kt_by_context.py
+"""
+
+import argparse
+import json
+import math
+import os
+from glob import glob
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import roc_auc_score
+
+# Set publication-quality font sizes
+plt.rcParams.update({
+    'font.size': 14,
+    'axes.titlesize': 16,
+    'axes.labelsize': 14,
+    'xtick.labelsize': 12,
+    'ytick.labelsize': 12,
+    'legend.fontsize': 12,
+})
+
+# Model name mapping for display
+MODEL_NAMES = {
+    'gptoss120b': 'GPT-OSS-120B',
+    'llama33_70b_instruct': 'Llama-3.3-70B-Instruct',
+    'qwen3next80binstruct': 'Qwen3-80B-Instruct',
+    'qwen3next80bthinking': 'Qwen3-80B-Thinking',
+}
+
+# Colors for each model
+MODEL_COLORS = {
+    'gptoss120b': '#1f77b4',  # blue
+    'llama33_70b_instruct': '#ff7f0e',  # orange
+    'qwen3next80binstruct': '#2ca02c',  # green
+    'qwen3next80bthinking': '#d62728',  # red
+}
+
+
+def normalize_mcq_answer(answer_str: str) -> str:
+    """Normalize MCQ answer format for consistent comparison."""
+    parts = [p.strip().upper() for p in answer_str.split(',')]
+    parts = [p for p in parts if p]
+    if parts and all(len(p) == 1 and p.isalpha() for p in parts):
+        return ', '.join(sorted(set(parts)))
+    return answer_str
+
+
+def numerical_match(answer1: str, answer2: str, atol: float = 0.01, rtol: float = 0.01) -> bool:
+    """Check if two answers are numerically close within tolerance."""
+    try:
+        a = float(answer1.strip())
+        b = float(answer2.strip())
+        return math.isclose(a, b, abs_tol=atol, rel_tol=rtol)
+    except (ValueError, AttributeError):
+        return False
+
+
+def answers_match(pred, actual):
+    """Check if predicted answer matches actual answer."""
+    if pred is None or actual is None:
+        return False
+
+    pred_str = str(pred).strip()
+    actual_str = str(actual).strip()
+
+    if pred_str == actual_str:
+        return True
+
+    pred_normalized = normalize_mcq_answer(pred_str)
+    actual_normalized = normalize_mcq_answer(actual_str)
+    if pred_normalized == actual_normalized:
+        return True
+
+    return numerical_match(pred_str, actual_str)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate KT by context length")
+    parser.add_argument(
+        "--results-dir", "-r",
+        type=str,
+        default="inference_data_kt_results",
+        help="Directory containing JSONL results files"
+    )
+    parser.add_argument(
+        "--output-dir", "-o",
+        type=str,
+        default="dataset_analysis/plots",
+        help="Directory to save output plots"
+    )
+    parser.add_argument(
+        "--no-plots",
+        action="store_true",
+        help="Skip generating plots"
+    )
+    return parser.parse_args()
+
+
+def extract_model_name(filename):
+    """Extract model identifier from filename."""
+    basename = os.path.basename(filename)
+    # Pattern: modelname_n500_bin10_hist50.jsonl
+    for model_key in MODEL_NAMES.keys():
+        if basename.startswith(model_key):
+            return model_key
+    return basename.replace('.jsonl', '')
+
+
+def load_results(jsonl_path):
+    """Load results from JSONL file."""
+    results = []
+    with open(jsonl_path, 'r') as f:
+        for line in f:
+            if line.strip():
+                results.append(json.loads(line))
+    return results
+
+
+def compute_metrics_by_bin(results):
+    """Compute metrics grouped by history_size."""
+    bins = defaultdict(list)
+
+    for r in results:
+        history_size = r.get('history_size', 50)
+        bins[history_size].append(r)
+
+    metrics = {}
+    for history_size in sorted(bins.keys()):
+        bin_results = bins[history_size]
+        n = len(bin_results)
+
+        # FKT: Collect valid predictions for AUC-ROC
+        y_true = []
+        y_pred = []
+        for r in bin_results:
+            actual = r.get('actual_score')
+            pred = r.get('predicted_question_level')
+            if actual is not None and pred is not None:
+                y_true.append(int(actual))
+                y_pred.append(int(pred))
+
+        # Compute AUC-ROC (requires both classes present)
+        fkt_auc = None
+        if len(set(y_true)) == 2 and len(y_true) > 0:
+            try:
+                fkt_auc = roc_auc_score(y_true, y_pred)
+            except ValueError:
+                pass
+
+        # FKT accuracy (for reference)
+        fkt_correct = sum(1 for t, p in zip(y_true, y_pred) if t == p)
+        fkt_acc = fkt_correct / len(y_true) if y_true else 0.0
+
+        # Cognitive accuracy (answer match)
+        cognitive_correct = sum(
+            1 for r in bin_results
+            if answers_match(r.get('predicted_student_answer'), r.get('actual_answer'))
+        )
+
+        metrics[history_size] = {
+            'n': n,
+            'fkt_auc': fkt_auc,
+            'fkt_acc': fkt_acc,
+            'fkt_valid': len(y_true),
+            'cognitive_acc': cognitive_correct / n if n > 0 else 0.0,
+        }
+
+    return metrics
+
+
+def print_table(all_metrics):
+    """Print metrics table to console."""
+    # Get all history sizes across all models
+    all_history_sizes = sorted(set(
+        hs for model_metrics in all_metrics.values()
+        for hs in model_metrics.keys()
+    ))
+
+    # Header
+    print("\n" + "=" * 100)
+    print("KT Performance by Context Length (History Size)")
+    print("=" * 100)
+
+    # Print FKT AUC-ROC table
+    print("\nFKT AUC-ROC (Question-Level):")
+    print("-" * 80)
+    header = f"{'History':>8}"
+    for model_key in all_metrics.keys():
+        header += f"  {MODEL_NAMES.get(model_key, model_key)[:20]:>20}"
+    print(header)
+    print("-" * 80)
+
+    for hs in all_history_sizes:
+        row = f"{hs:>8}"
+        for model_key in all_metrics.keys():
+            if hs in all_metrics[model_key]:
+                auc = all_metrics[model_key][hs]['fkt_auc']
+                if auc is not None:
+                    row += f"  {auc:>20.3f}"
+                else:
+                    row += f"  {'N/A':>20}"
+            else:
+                row += f"  {'N/A':>20}"
+        print(row)
+
+    # Print Cognitive accuracy table
+    print("\nCognitive Accuracy (Answer Prediction):")
+    print("-" * 80)
+    print(header)
+    print("-" * 80)
+
+    for hs in all_history_sizes:
+        row = f"{hs:>8}"
+        for model_key in all_metrics.keys():
+            if hs in all_metrics[model_key]:
+                acc = all_metrics[model_key][hs]['cognitive_acc']
+                row += f"  {acc:>20.3f}"
+            else:
+                row += f"  {'N/A':>20}"
+        print(row)
+
+
+def plot_results(all_metrics, output_dir):
+    """Generate plot with all models."""
+    os.makedirs(output_dir, exist_ok=True)
+
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    # Plot 1: FKT AUC-ROC
+    for model_key, metrics in all_metrics.items():
+        history_sizes = sorted(metrics.keys())
+        # Filter out None values
+        valid_hs = [hs for hs in history_sizes if metrics[hs]['fkt_auc'] is not None]
+        fkt_aucs = [metrics[hs]['fkt_auc'] for hs in valid_hs]
+
+        if valid_hs:
+            axes[0].plot(
+                valid_hs, fkt_aucs,
+                marker='o', markersize=4,
+                color=MODEL_COLORS.get(model_key, 'gray'),
+                label=MODEL_NAMES.get(model_key, model_key),
+                linewidth=2
+            )
+
+    axes[0].set_xlabel('History Size (# prior interactions)')
+    axes[0].set_ylabel('AUC-ROC')
+    axes[0].set_title('FKT AUC-ROC vs Context Length')
+    axes[0].legend(loc='best')
+    axes[0].grid(True, alpha=0.3)
+    axes[0].set_xlim(40, 410)
+    axes[0].axhline(y=0.5, color='gray', linestyle='--', alpha=0.5, label='Random')
+
+    # Plot 2: Cognitive Accuracy
+    for model_key, metrics in all_metrics.items():
+        history_sizes = sorted(metrics.keys())
+        cognitive_accs = [metrics[hs]['cognitive_acc'] for hs in history_sizes]
+
+        axes[1].plot(
+            history_sizes, cognitive_accs,
+            marker='o', markersize=4,
+            color=MODEL_COLORS.get(model_key, 'gray'),
+            label=MODEL_NAMES.get(model_key, model_key),
+            linewidth=2
+        )
+
+    axes[1].set_xlabel('History Size (# prior interactions)')
+    axes[1].set_ylabel('Accuracy')
+    axes[1].set_title('Cognitive Modeling Accuracy vs Context Length')
+    axes[1].legend(loc='best')
+    axes[1].grid(True, alpha=0.3)
+    axes[1].set_xlim(40, 410)
+
+    plt.tight_layout()
+
+    plot_path = os.path.join(output_dir, 'kt_context_scaling.png')
+    plt.savefig(plot_path, dpi=150)
+    plt.close()
+
+    print(f"\nSaved: {plot_path}")
+
+
+def main():
+    args = parse_args()
+
+    # Find all JSONL files
+    jsonl_files = glob(os.path.join(args.results_dir, '*.jsonl'))
+
+    if not jsonl_files:
+        print(f"No JSONL files found in {args.results_dir}")
+        return
+
+    print(f"Found {len(jsonl_files)} result files:")
+    for f in jsonl_files:
+        print(f"  - {os.path.basename(f)}")
+
+    # Load and analyze each model
+    all_metrics = {}
+
+    for jsonl_path in sorted(jsonl_files):
+        model_key = extract_model_name(jsonl_path)
+        print(f"\nProcessing {MODEL_NAMES.get(model_key, model_key)}...")
+
+        results = load_results(jsonl_path)
+        print(f"  Loaded {len(results):,} predictions")
+
+        metrics = compute_metrics_by_bin(results)
+        all_metrics[model_key] = metrics
+
+        # Print quick summary
+        history_sizes = sorted(metrics.keys())
+        valid_aucs = [metrics[hs]['fkt_auc'] for hs in history_sizes if metrics[hs]['fkt_auc'] is not None]
+        avg_auc = np.mean(valid_aucs) if valid_aucs else 0.0
+        avg_cognitive = np.mean([metrics[hs]['cognitive_acc'] for hs in history_sizes])
+        print(f"  Avg FKT AUC-ROC: {avg_auc:.3f}")
+        print(f"  Avg Cognitive accuracy: {avg_cognitive:.3f}")
+
+    # Print detailed table
+    print_table(all_metrics)
+
+    # Generate plot
+    if not args.no_plots:
+        plot_results(all_metrics, args.output_dir)
+
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()

Code/find_duplicate_problem_body.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Export rows that share the same Problem Body but have different problem_id.
+
+Default input:
+- ../Data/Problems.csv
+
+Default output:
+- ../Data/Problems_same_body_different_problem_id.csv
+
+The output includes all original columns plus:
+- duplicate_group_id
+- distinct_problem_id_count
+- distinct_problem_ids
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import html
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Set
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+
+
+def normalize_body(text: str, strip_html: bool, collapse_whitespace: bool) -> str:
+    """Normalize Problem Body text for grouping."""
+    value = html.unescape(text or "")
+    if strip_html:
+        value = _TAG_RE.sub("", value)
+    if collapse_whitespace:
+        value = _WS_RE.sub(" ", value).strip()
+    return value
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Find rows in Problems.csv where the same Problem Body is mapped "
+            "to different problem_id values."
+        )
+    )
+    parser.add_argument(
+        "--input-csv",
+        type=Path,
+        default=Path("../Data/Problems.csv"),
+        help="Path to Problems.csv",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("../Results/Problems_same_body_different_problem_id.csv"),
+        help="Output CSV path",
+    )
+    parser.add_argument(
+        "--body-column",
+        type=str,
+        default="Problem Body",
+        help="Column name for problem statement text",
+    )
+    parser.add_argument(
+        "--id-column",
+        type=str,
+        default="problem_id",
+        help="Column name for problem identifier",
+    )
+    parser.add_argument(
+        "--strip-html",
+        action="store_true",
+        help="Strip HTML tags before grouping",
+    )
+    parser.add_argument(
+        "--collapse-whitespace",
+        action="store_true",
+        help="Collapse runs of whitespace before grouping",
+    )
+
+    args = parser.parse_args()
+
+    input_csv = args.input_csv.resolve()
+    output_csv = args.output_csv.resolve()
+
+    with input_csv.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        fieldnames = reader.fieldnames or []
+
+        if args.body_column not in fieldnames:
+            raise ValueError(f"Missing body column '{args.body_column}' in {input_csv}")
+        if args.id_column not in fieldnames:
+            raise ValueError(f"Missing id column '{args.id_column}' in {input_csv}")
+
+        rows: List[dict] = list(reader)
+
+    groups: Dict[str, List[int]] = defaultdict(list)
+    group_ids: Dict[str, Set[str]] = defaultdict(set)
+
+    for idx, row in enumerate(rows):
+        body_raw = row.get(args.body_column, "")
+        body_key = normalize_body(
+            body_raw,
+            strip_html=args.strip_html,
+            collapse_whitespace=args.collapse_whitespace,
+        )
+        if not body_key:
+            continue
+
+        problem_id = str(row.get(args.id_column, "")).strip()
+        groups[body_key].append(idx)
+        if problem_id:
+            group_ids[body_key].add(problem_id)
+
+    duplicate_keys = [k for k, ids in group_ids.items() if len(ids) > 1]
+
+    # Preserve first-seen order of duplicate groups.
+    duplicate_keys.sort(key=lambda k: groups[k][0])
+
+    output_rows: List[dict] = []
+    for group_num, key in enumerate(duplicate_keys, start=1):
+        ids_sorted = sorted(group_ids[key])
+        ids_joined = ";".join(ids_sorted)
+
+        for row_idx in groups[key]:
+            out_row = dict(rows[row_idx])
+            out_row["duplicate_group_id"] = str(group_num)
+            out_row["distinct_problem_id_count"] = str(len(ids_sorted))
+            out_row["distinct_problem_ids"] = ids_joined
+            output_rows.append(out_row)
+
+    output_csv.parent.mkdir(parents=True, exist_ok=True)
+    output_fieldnames = fieldnames + [
+        "duplicate_group_id",
+        "distinct_problem_id_count",
+        "distinct_problem_ids",
+    ]
+
+    with output_csv.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=output_fieldnames)
+        writer.writeheader()
+        writer.writerows(output_rows)
+
+    print(f"Input rows: {len(rows)}")
+    print(f"Duplicate body groups (different problem_id): {len(duplicate_keys)}")
+    print(f"Output rows: {len(output_rows)}")
+    print(f"Wrote: {output_csv}")
+
+
+if __name__ == "__main__":
+    main()

Code/find_duplicate_problem_id.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Export rows that have duplicated problem_id values.
+
+Default input:
+- ../Data/Problems.csv
+
+Default output:
+- ../Results/Problems_duplicated_problem_id.csv
+
+The output includes all original columns plus:
+- duplicate_group_id
+- duplicate_problem_id_count
+- distinct_problem_body_count
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import html
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Set
+
+_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+
+
+def normalize_body(text: str, strip_html: bool, collapse_whitespace: bool) -> str:
+    """Normalize Problem Body text for distinct-body counting."""
+    value = html.unescape(text or "")
+    if strip_html:
+        value = _TAG_RE.sub("", value)
+    if collapse_whitespace:
+        value = _WS_RE.sub(" ", value).strip()
+    return value
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Find rows in Problems.csv where problem_id is duplicated."
+    )
+    parser.add_argument(
+        "--input-csv",
+        type=Path,
+        default=Path("../Data/Problems.csv"),
+        help="Path to Problems.csv",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("../Results/Problems_duplicated_problem_id.csv"),
+        help="Output CSV path",
+    )
+    parser.add_argument(
+        "--id-column",
+        type=str,
+        default="problem_id",
+        help="Column name for problem identifier",
+    )
+    parser.add_argument(
+        "--body-column",
+        type=str,
+        default="Problem Body",
+        help="Column name for problem statement text",
+    )
+    parser.add_argument(
+        "--strip-html",
+        action="store_true",
+        help="Strip HTML tags before counting distinct problem bodies",
+    )
+    parser.add_argument(
+        "--collapse-whitespace",
+        action="store_true",
+        help="Collapse runs of whitespace before counting distinct problem bodies",
+    )
+
+    args = parser.parse_args()
+
+    input_csv = args.input_csv.resolve()
+    output_csv = args.output_csv.resolve()
+
+    with input_csv.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        fieldnames = reader.fieldnames or []
+
+        if args.id_column not in fieldnames:
+            raise ValueError(f"Missing id column '{args.id_column}' in {input_csv}")
+        if args.body_column not in fieldnames:
+            raise ValueError(f"Missing body column '{args.body_column}' in {input_csv}")
+
+        rows: List[dict] = list(reader)
+
+    groups: Dict[str, List[int]] = defaultdict(list)
+    for idx, row in enumerate(rows):
+        problem_id = str(row.get(args.id_column, "")).strip()
+        if not problem_id:
+            continue
+        groups[problem_id].append(idx)
+
+    duplicate_ids = [pid for pid, row_idxs in groups.items() if len(row_idxs) > 1]
+
+    # Preserve first-seen order of duplicate groups.
+    duplicate_ids.sort(key=lambda pid: groups[pid][0])
+
+    output_rows: List[dict] = []
+    for group_num, pid in enumerate(duplicate_ids, start=1):
+        row_idxs = groups[pid]
+
+        distinct_bodies: Set[str] = set()
+        for row_idx in row_idxs:
+            body_raw = rows[row_idx].get(args.body_column, "")
+            distinct_bodies.add(
+                normalize_body(
+                    body_raw,
+                    strip_html=args.strip_html,
+                    collapse_whitespace=args.collapse_whitespace,
+                )
+            )
+
+        for row_idx in row_idxs:
+            out_row = dict(rows[row_idx])
+            out_row["duplicate_group_id"] = str(group_num)
+            out_row["duplicate_problem_id_count"] = str(len(row_idxs))
+            out_row["distinct_problem_body_count"] = str(len(distinct_bodies))
+            output_rows.append(out_row)
+
+    output_csv.parent.mkdir(parents=True, exist_ok=True)
+    output_fieldnames = fieldnames + [
+        "duplicate_group_id",
+        "duplicate_problem_id_count",
+        "distinct_problem_body_count",
+    ]
+
+    with output_csv.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=output_fieldnames)
+        writer.writeheader()
+        writer.writerows(output_rows)
+
+    print(f"Input rows: {len(rows)}")
+    print(f"Duplicated {args.id_column} groups: {len(duplicate_ids)}")
+    print(f"Output rows: {len(output_rows)}")
+    print(f"Wrote: {output_csv}")
+
+
+if __name__ == "__main__":
+    main()

Code/gptoss120bvllmmcq.py

@@ -0,0 +1,31 @@
+"""
+Knowledge Tracing inference with GPT-OSS-120B model.
+
+Usage:
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120bvllmmcq.py \
+        --data-dir foundationalktdataset/ \
+        --num-gpus 4 \
+        --batch-size 10 \
+        --cache-dir /data1/ \
+        --num-students 500 \
+        --bin-size 50 \
+        --min-history 50
+"""
+
+from kt_inference_base import run_inference
+
+MODEL_CONFIG = {
+    "model_id": "openai/gpt-oss-120b",
+    "gen_configs": {
+        "temperature": 0.7,
+        "top_p": 0.95,
+        "top_k": 20,
+        "max_tokens": 32768,
+        "repetition_penalty": 1.0,
+    },
+    "output_prefix": "gptoss120b",
+    "system_prompt_prefix": "Reasoning: medium\n\n",
+}
+
+if __name__ == "__main__":
+    run_inference(MODEL_CONFIG)

Code/kt_inference_base.py

@@ -0,0 +1,849 @@
+"""
+Base module for Knowledge Tracing LLM inference.
+
+This module contains all shared logic for running KT inference with different models.
+Each model script imports this and provides model-specific configuration.
+
+Usage in model scripts:
+    from kt_inference_base import run_inference
+
+    MODEL_CONFIG = {
+        "model_id": "model/name",
+        "gen_configs": {...},
+        "output_prefix": "prefix",
+        "system_prompt_prefix": "",  # e.g., "Reasoning: medium\n\n"
+    }
+
+    if __name__ == "__main__":
+        run_inference(MODEL_CONFIG)
+"""
+
+import argparse
+import contextlib
+import os
+from vllm import LLM, SamplingParams
+import pandas as pd
+import gc
+import torch
+from vllm.distributed.parallel_state import (
+    destroy_model_parallel,
+    destroy_distributed_environment,
+)
+import json
+import re
+import numpy as np
+from tqdm import tqdm
+from multiprocessing import Pool, cpu_count
+from clean_utils import clean_problem_body
+from cleantext import clean_text as clean_text_legacy
+
+
+class NumpyEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles numpy types."""
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)
+
+
+# Batch processing config defaults
+DEFAULT_BATCH_SIZE = 10000
+DEFAULT_NUM_STUDENTS = 500
+DEFAULT_BIN_SIZE = 50
+DEFAULT_MIN_HISTORY = 50
+
+# Input file names
+STUDENT_FILE = "Interactions.csv"
+PROBLEMS_FILE = "Problems.csv"
+SKILL_FILE = "Skills.csv"
+
+# Base system prompt (without any prefix like "Reasoning: medium")
+BASE_SYSTEM_PROMPT = """You are a reasoning model trained to simulate a student's evolving knowledge and response behavior in mathematics.
+
+Your goal is to infer, from past problem–answer pairs, how this same student is likely to perform on a new problem — at multiple levels of granularity.
+
+You must reason about the student's learning progression, skill mastery, and recurring misconceptions, then produce structured predictions for the new item.
+
+---
+
+Your Task:
+
+Generate three coordinated predictions for this student:
+
+1) **Skill-level knowledge tracing (0 or 1):** Whether the student has mastered the underlying skill involved in the new problem.
+2) **Question-level knowledge tracing (0 or 1):** Whether the student will answer this specific problem correctly.
+3) **Cognitive-level prediction (string):** The exact answer text or option the student would most likely produce, written in their own response style.
+
+---
+
+Reasoning Guidelines:
+
+- Use the student's historical data (problems, answers, hints, timestamps) to infer learning and forgetting patterns.
+- Consider recency and exposure: later timestamps often indicate updated knowledge.
+- Treat `UsedHint=True` or `SawAnswer=True` as evidence that the student's recorded answer may not reflect true mastery — they might have seen or been helped toward the solution.
+- Attend to how the student's accuracy, style, and misconceptions evolve over time.
+- You may think step-by-step internally, but your final output must follow the format below.
+---
+
+Output Format:
+
+When you are done reasoning, **finish your response with** the JSON object in this exact structure:
+
+For Multiple Choice (select 1) problems:
+{
+"skill_level": 0 or 1,
+"question_level": 0 or 1,
+"student_answer": "A" (single letter only)
+}
+
+For Multiple Choice (select all) problems:
+{
+"skill_level": 0 or 1,
+"question_level": 0 or 1,
+"student_answer": "A, C" (comma-separated letters if multiple selections)
+}
+
+For Fill-in problems:
+{
+"skill_level": 0 or 1,
+"question_level": 0 or 1,
+"student_answer": "<string exactly as this student would write (e.g., 'x=3', '3/5', '12')>"
+}
+
+Predictions must be consistent. If you predict question_level to be 1, then student_answer must match the correct answer. If you predict question_level to be 0, student_answer must not match the correct answer."""
+
+
+def parse_args(default_output_jsonl):
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Knowledge Tracing with LLM")
+    parser.add_argument(
+        "--batch-size", "-b",
+        type=int,
+        default=DEFAULT_BATCH_SIZE,
+        help=f"Batch size for LLM inference (default: {DEFAULT_BATCH_SIZE})"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        type=str,
+        default=None,
+        help="Output JSONL file path (overrides auto-generated name)"
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=".",
+        help="Output directory for results (default: current directory)"
+    )
+    parser.add_argument(
+        "--data-dir", "-d",
+        type=str,
+        default=".",
+        help="Directory containing input CSV files (default: current directory)"
+    )
+    parser.add_argument(
+        "--cache-dir", "-c",
+        type=str,
+        default=None,
+        help="Directory for vLLM model cache (default: vLLM default)"
+    )
+    parser.add_argument(
+        "--num-students", "-n",
+        type=int,
+        default=DEFAULT_NUM_STUDENTS,
+        help=f"Number of students to sample (default: {DEFAULT_NUM_STUDENTS}, use 0 or -1 for all students)"
+    )
+    parser.add_argument(
+        "--bin-size",
+        type=int,
+        default=DEFAULT_BIN_SIZE,
+        help=f"Size of each prediction bin (default: {DEFAULT_BIN_SIZE})"
+    )
+    parser.add_argument(
+        "--min-history",
+        type=int,
+        default=DEFAULT_MIN_HISTORY,
+        help=f"Minimum history size before making predictions (default: {DEFAULT_MIN_HISTORY})"
+    )
+    parser.add_argument(
+        "--num-gpus",
+        type=int,
+        default=1,
+        help="Number of GPUs for tensor parallelism (default: 1)"
+    )
+    parser.add_argument(
+        "--max-num-seqs",
+        type=int,
+        default=None,
+        help="Maximum number of sequences to process in a batch (vLLM, default: 256)"
+    )
+    parser.add_argument(
+        "--reasoning-level",
+        type=str,
+        choices=["none", "low", "medium", "high"],
+        default=None,
+        help="Reasoning level for GPT-OSS models only. Default: uses model config (medium for GPT-OSS, none for Qwen)"
+    )
+    parser.add_argument(
+        "--max-model-len",
+        type=int,
+        default=None,
+        help="Maximum sequence length in tokens (vLLM, default: model's context length)"
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.9,
+        help="Fraction of GPU memory to use (vLLM, default: 0.9, range: 0.0-1.0)"
+    )
+    parser.add_argument(
+        "--legacy-clean",
+        action="store_true",
+        default=False,
+        help="Use legacy text cleaner (cleantext.py) instead of clean_utils.py"
+    )
+    return parser.parse_args()
+
+
+def label_answer_options(answer_string):
+    """
+    Convert pipe-delimited answers to lettered format.
+    Input: "Han is correct || Elena is correct || Both are correct"
+    Output: {"A": "Han is correct", "B": "Elena is correct", "C": "Both are correct"}
+    """
+    if pd.isna(answer_string) or answer_string == '':
+        return None
+
+    options = [opt.strip() for opt in answer_string.split('||')]
+    letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
+    return {letters[i]: opt for i, opt in enumerate(options) if i < len(letters)}
+
+
+def clean_html_and_normalize(text):
+    """
+    Remove HTML tags and normalize text for comparison.
+    """
+    if pd.isna(text):
+        return ""
+    # Remove HTML tags
+    text = re.sub(r'<[^>]+>', '', str(text))
+    # Normalize whitespace
+    text = ' '.join(text.split())
+    # Remove extra spaces around colons
+    text = re.sub(r'\s*:\s*', ':', text)
+    return text.strip()
+
+
+def match_student_answer_to_letters(student_answer_text, answer_options_dict):
+    """
+    Match student's comma-delineated answers to letter options.
+
+    Args:
+        student_answer_text: String like "Answer A text , Answer C text , Answer B text"
+        answer_options_dict: Dict like {"A": "Answer A text", "B": "Answer B text", ...}
+
+    Returns:
+        String like "A, B, C" or original text if no match
+    """
+    if pd.isna(student_answer_text) or not answer_options_dict:
+        return student_answer_text
+
+    # Split by " , " (comma with spaces, which is the delimiter used in the actual_answer)
+    student_answers = [ans.strip() for ans in str(student_answer_text).split(' , ')]
+
+    # Clean and normalize all options for comparison
+    normalized_options = {
+        letter: clean_html_and_normalize(text)
+        for letter, text in answer_options_dict.items()
+    }
+
+    matched_letters = []
+    for student_ans in student_answers:
+        normalized_student = clean_html_and_normalize(student_ans)
+
+        # Try to find exact match first
+        for letter, normalized_option in normalized_options.items():
+            if normalized_student == normalized_option:
+                matched_letters.append(letter)
+                break
+        else:
+            # If no exact match, try substring match (student answer contained in option or vice versa)
+            for letter, normalized_option in normalized_options.items():
+                if (normalized_student in normalized_option or
+                    normalized_option in normalized_student):
+                    matched_letters.append(letter)
+                    break
+
+    # Return comma-separated letters if we found matches, otherwise return original
+    if matched_letters:
+        return ', '.join(sorted(set(matched_letters)))  # Remove duplicates and sort
+    return student_answer_text
+
+
+def get_correct_option_letters(answer_options, correct_answers):
+    """
+    Determine which letter(s) correspond to correct answer(s).
+
+    Args:
+        answer_options: Dict like {"A": "Han is correct", "B": "Elena is correct", ...}
+        correct_answers: String like "Both are correct" or "Han is correct || Elena is correct"
+
+    Returns:
+        String like "C" or "A, B" depending on how many correct options
+    """
+    if not answer_options or pd.isna(correct_answers):
+        return correct_answers
+
+    # Split correct answers if multiple
+    correct_list = [ans.strip() for ans in correct_answers.split('||')]
+
+    # Find matching letters
+    correct_letters = []
+    for letter, text in answer_options.items():
+        if text in correct_list:
+            correct_letters.append(letter)
+
+    return ', '.join(sorted(correct_letters)) if correct_letters else correct_answers
+
+
+def format_answer_options_for_prompt(answer_options):
+    """
+    Format answer options dictionary for display in prompt.
+    Input: {"A": "Han is correct", "B": "Elena is correct", ...}
+    Output: "A) Han is correct\nB) Elena is correct\n..."
+    """
+    if not answer_options:
+        return None
+
+    return '\n'.join([f"{letter}) {text}" for letter, text in answer_options.items()])
+
+
+def create_user_prompt(student_history, new_problem, problem_df):
+    """
+    Creates a user prompt with student history and new problem.
+
+    Args:
+        student_history: List of dicts with keys: problem_id, timestamp, problem_text,
+                        correct_answer, student_answer, used_hint, saw_answer
+        new_problem: Dict with keys: problem_text, correct_answer, used_hint, saw_answer,
+                     answer_options (optional)
+    """
+    prompt = "Task Description:\n\n"
+    prompt += "Your task is to model a single student's learning process and predict how they will respond to a new mathematics problem based on their prior work.\n\n"
+
+    prompt += """You will produce three coordinated predictions:
+
+    1) **Skill-level knowledge tracing (0 or 1):** Predict whether this student has mastered the underlying skill involved in the new problem.
+    2) **Question-level knowledge tracing (0 or 1):** Predict whether this student will answer this specific problem correctly.
+    3) **Cognitive-level prediction (string):** Generate the exact answer the student would most likely produce.
+       - For Multiple Choice (select 1): Predict a single letter (e.g., "A" or "B")
+       - For Multiple Choice (select all): Predict comma-separated letters (e.g., "A, C" or "B, D")
+       - For Fill-in problems: Predict the exact text the student would write
+    """
+
+    prompt += """---
+
+    Provided Data:
+
+    You will receive:
+    - ProblemID: <id>
+    - Timestamp: <timestamp>
+    - Problem: <problem text>
+    - Problem Type: Multiple Choice (select 1) / Multiple Choice (select all) / Fill-in Problem
+    - Options: Answer choices in format "A) ...\nB) ...\nC) ..."
+    - Correct Answer(s): The letter(s) or text of correct answer(s)
+    - Student's First Answer: Letter(s) or fill-in text
+    - UsedHint: <True/False>
+    - SawAnswer: <True/False>
+    - Skill: <skill_name_or_id>
+    - A new problem (with optional answer choices), skill metadata, and context flags (`UsedHint`, `SawAnswer`).
+
+    # About the context flags:
+    - **UsedHint = True** → The student viewed or used a hint while solving this problem.
+    - **SawAnswer = True** → The student saw the correct answer before or during the attempt.
+    When either of these flags is True, treat the corresponding response as *less reliable evidence of mastery* — it indicates that the student has not fully learned the concept and required help solving the problem.
+"""
+
+    prompt += "**Student's Previous Problems:**\n\n"
+    for item in student_history:
+        prompt += f"Timestamp: {item['timestamp']}\n"
+        prompt += f"Problem: {item['problem_text']}\n"
+        prompt += f"Problem Type: {item['problem_type']}\n"
+        if item.get('answer_options_formatted'):
+            prompt += f"Options:\n{item['answer_options_formatted']}\n"
+        prompt += f"Correct Answer: {item['correct_answer']}\n"
+        prompt += f"Student's First Answer: {item['student_answer']}\n"
+        prompt += f"UsedHint: {item['used_hint']}\n"
+        prompt += f"SawAnswer: {item['saw_answer']}\n"
+        if item.get('node_name'):
+            prompt += f"Skill: {item['node_name']}\n"
+        else:
+            prompt += f"Skill: Undefined\n"
+        prompt += "---\n\n"
+
+    prompt += "**New Problem to Predict:**\n\n"
+    prompt += f"Timestamp: {new_problem['timestamp']}\n"
+    prompt += f"Problem: {new_problem['problem_text']}\n"
+    prompt += f"Problem Type: {new_problem['problem_type']}\n"
+    if new_problem.get('answer_options_formatted'):
+        prompt += f"Answer Options:\n{new_problem['answer_options_formatted']}\n"
+    prompt += f"Correct Answer: {new_problem['correct_answer']}\n"
+    if new_problem.get('node_name'):
+        prompt += f"Skill: {new_problem['node_name']}\n"
+    else:
+        prompt += f"Skill: Undefined\n"
+
+    return prompt
+
+
+def extract_json_prediction(response_text):
+    """Extract the final JSON prediction from the model's response."""
+    # Find all JSON objects in the response
+    json_matches = re.findall(r'\{[\s\S]*?\}', response_text)
+
+    if json_matches:
+        # Take the last JSON object
+        json_str = json_matches[-1]
+        try:
+            # Decode escape sequences (like \n) before parsing
+            json_str = json_str.encode().decode('unicode_escape')
+            json_str = json_str.strip()
+            return json.loads(json_str)
+        except json.JSONDecodeError as e:
+            print(f"JSON decode error: {e}")
+            print(f"Attempted to parse:\n{json_str}")
+        except Exception as e:
+            print(f"Error processing JSON: {e}")
+    return None
+
+
+def get_prediction_id(meta):
+    """Generate unique ID for a prediction"""
+    return f"{meta['user_id']}_{meta['bin_number']}_{meta['prediction_type']}"
+
+
+def load_completed_predictions(output_jsonl):
+    """Load already-completed prediction IDs from JSONL file"""
+    completed = set()
+    if os.path.exists(output_jsonl):
+        with open(output_jsonl, 'r') as f:
+            for line in f:
+                if line.strip():
+                    result = json.loads(line)
+                    completed.add(result['prediction_id'])
+        print(f"Loaded {len(completed)} completed predictions from {output_jsonl}")
+    return completed
+
+
+def make_process_single_user(system_prompt):
+    """Create a process_single_user function with the given system prompt."""
+    def process_single_user(args):
+        """Process a single user's data and return prompts and metadata."""
+        user_id, user_records, min_history, bin_size = args
+
+        prompts = []
+        metadata = []
+
+        # Check if user has at least min_history + 1 rows
+        if len(user_records) < min_history + 1:
+            return prompts, metadata
+
+        num_bins = (len(user_records) - min_history) // bin_size
+
+        # Build initial history
+        student_history = []
+        for hist_idx in range(min_history):
+            row = user_records[hist_idx]
+            student_history.append({
+                'problem_id': row['problem_id'],
+                'timestamp': row['end_time'],
+                'problem_text': row['cleaned body'],
+                'correct_answer': row['Fill-in Answers'],
+                'answer_options': row['answer_options'] if pd.notna(row['answer_options']) else None,
+                'answer_options_formatted': row['answer_options_formatted'] if pd.notna(row.get('answer_options_formatted')) else None,
+                'student_answer': row['answer_text'],
+                'used_hint': row['hint_count'] > 0,
+                'saw_answer': row['saw_answer'],
+                'problem_type': row['Problem Type'],
+                'node_name': row.get('node_name')
+            })
+
+        for bin_idx in range(num_bins):
+            # Extend history with previous bin's items
+            if bin_idx > 0:
+                prev_bin_start = min_history + ((bin_idx - 1) * bin_size)
+                prev_bin_end = min_history + (bin_idx * bin_size)
+                for hist_idx in range(prev_bin_start, prev_bin_end):
+                    row = user_records[hist_idx]
+                    student_history.append({
+                        'problem_id': row['problem_id'],
+                        'timestamp': row['end_time'],
+                        'problem_text': row['cleaned body'],
+                        'correct_answer': row['Fill-in Answers'],
+                        'answer_options': row['answer_options'] if pd.notna(row['answer_options']) else None,
+                        'answer_options_formatted': row['answer_options_formatted'] if pd.notna(row.get('answer_options_formatted')) else None,
+                        'student_answer': row['answer_text'],
+                        'used_hint': row['hint_count'] > 0,
+                        'saw_answer': row['saw_answer'],
+                        'problem_type': row['Problem Type'],
+                        'node_name': row.get('node_name')
+                    })
+
+            history_end = min_history + (bin_idx * bin_size)
+            bin_start = history_end
+            bin_end = bin_start + bin_size
+            current_bin = user_records[bin_start:bin_end]
+
+            # Find first correct and first incorrect in this bin
+            first_correct_idx = None
+            first_incorrect_idx = None
+
+            for idx, row in enumerate(current_bin):
+                actual_idx = bin_start + idx
+                score = row['discrete_score']
+
+                if score == 1 and first_correct_idx is None:
+                    first_correct_idx = actual_idx
+                if score == 0 and first_incorrect_idx is None:
+                    first_incorrect_idx = actual_idx
+
+                if first_correct_idx is not None and first_incorrect_idx is not None:
+                    break
+
+            # Create predictions for found cases
+            for target_idx, prediction_type in [
+                (first_correct_idx, 'correct'),
+                (first_incorrect_idx, 'incorrect')
+            ]:
+                if target_idx is None:
+                    continue
+
+                target_row = user_records[target_idx]
+                new_problem = {
+                    'problem_text': target_row['cleaned body'],
+                    'correct_answer': target_row['Fill-in Answers'],
+                    'answer_options': target_row['answer_options'] if pd.notna(target_row['answer_options']) else None,
+                    'answer_options_formatted': target_row['answer_options_formatted'] if pd.notna(target_row.get('answer_options_formatted')) else None,
+                    'problem_type': target_row['Problem Type'],
+                    'timestamp': target_row['end_time'],
+                    'node_name': target_row.get('node_name')
+                }
+
+                user_prompt = create_user_prompt(student_history, new_problem, None)
+                full_prompt = system_prompt + "\n\n" + user_prompt
+
+                prompts.append(full_prompt)
+                metadata.append({
+                    'prediction_id': f"{user_id}_{bin_idx}_{prediction_type}",
+                    'row_index': target_idx,
+                    'user_id': user_id,
+                    'history_size': len(student_history),
+                    'bin_number': bin_idx,
+                    'prediction_type': prediction_type,
+                    'id': target_row.get('id_x', None),
+                    'problem_id': target_row.get('problem_id', None),
+                    'problem_type': target_row['Problem Type'],
+                    'actual_answer': target_row['answer_text'],
+                    'correct_answer': target_row['Fill-in Answers'],
+                    'actual_score': target_row['discrete_score'],
+                    'prompt': full_prompt
+                })
+
+        return prompts, metadata
+
+    return process_single_user
+
+
+def append_results_jsonl(results, output_jsonl):
+    """Append batch results to JSONL file"""
+    with open(output_jsonl, 'a') as f:
+        for result in results:
+            f.write(json.dumps(result, cls=NumpyEncoder) + '\n')
+
+
+def process_batch(batch_metadata, batch_response_texts):
+    """Process a batch of responses and return results."""
+    batch_results = []
+
+    for metadata, response_text in zip(batch_metadata, batch_response_texts):
+        # Extract prediction
+        prediction = extract_json_prediction(response_text)
+
+        if prediction:
+            batch_results.append({
+                **metadata,
+                'predicted_skill_level': prediction.get('skill_level'),
+                'predicted_question_level': prediction.get('question_level'),
+                'predicted_student_answer': prediction.get('student_answer'),
+                'full_response': response_text
+            })
+        else:
+            batch_results.append({
+                **metadata,
+                'predicted_skill_level': None,
+                'predicted_question_level': None,
+                'predicted_student_answer': None,
+                'full_response': response_text
+            })
+
+    return batch_results
+
+
+# Global variable to hold process_single_user function for multiprocessing
+_process_single_user_func = None
+
+
+def _process_single_user_wrapper(args):
+    """Wrapper for multiprocessing that uses the global function."""
+    return _process_single_user_func(args)
+
+
+def run_inference(config):
+    """
+    Main inference function that runs KT prediction with the given model config.
+
+    Args:
+        config: Dict with keys:
+            - model_id: HuggingFace model ID
+            - gen_configs: Dict of generation parameters
+            - output_prefix: Prefix for output filename
+            - system_prompt_prefix: Optional prefix for system prompt (e.g., "Reasoning: medium\n\n")
+    """
+    global _process_single_user_func
+
+    model_id = config["model_id"]
+    gen_configs = config["gen_configs"]
+    output_prefix = config["output_prefix"]
+
+    # Parse arguments first (needed for reasoning level)
+    default_output_jsonl = f"{output_prefix}.jsonl"
+    args = parse_args(default_output_jsonl)
+
+    # Determine system prompt prefix
+    # CLI --reasoning-level overrides model config if provided
+    if args.reasoning_level is not None:
+        if args.reasoning_level == "none":
+            system_prompt_prefix = ""
+        else:
+            system_prompt_prefix = f"Reasoning: {args.reasoning_level}\n\n"
+    else:
+        system_prompt_prefix = config.get("system_prompt_prefix", "")
+
+    # Build full system prompt
+    system_prompt = system_prompt_prefix + BASE_SYSTEM_PROMPT
+
+    # Create the process_single_user function with this system prompt
+    _process_single_user_func = make_process_single_user(system_prompt)
+
+    batch_size = args.batch_size
+    data_dir = args.data_dir
+    cache_dir = args.cache_dir
+    num_students = args.num_students
+    bin_size = args.bin_size
+    min_history = args.min_history
+
+    # Generate output filename with params
+    n_str = "all" if num_students <= 0 else str(num_students)
+    params_suffix = f"_n{n_str}_bin{bin_size}_hist{min_history}"
+
+    if args.output:
+        # Use explicit output path
+        output_jsonl = args.output
+    else:
+        # Auto-generate filename in output directory
+        filename = f"{output_prefix}{params_suffix}.jsonl"
+        output_jsonl = os.path.join(args.output_dir, filename)
+
+    # Build input file paths
+    student_csv = os.path.join(data_dir, STUDENT_FILE)
+    problems_csv = os.path.join(data_dir, PROBLEMS_FILE)
+    skill_csv = os.path.join(data_dir, SKILL_FILE)
+
+    print(f"Model: {model_id}")
+    print(f"Data directory: {data_dir}")
+    print(f"Batch size: {batch_size}")
+    print(f"Output JSONL: {output_jsonl}")
+    print(f"Num students: {num_students if num_students > 0 else 'all'}")
+    print(f"Bin size: {bin_size}")
+    print(f"Min history: {min_history}")
+    if cache_dir:
+        print(f"Model cache: {cache_dir}")
+    print(f"Text cleaner: {'legacy (cleantext.py)' if args.legacy_clean else 'default (clean_utils.py)'}")
+
+    # Load the data
+    print("\nLoading data...")
+    student_df = pd.read_csv(student_csv)
+    student_df = student_df.sort_values(['user_id', 'id']).reset_index(drop=True)
+    problems_df = pd.read_csv(problems_csv)
+    clean_func = clean_text_legacy if args.legacy_clean else clean_problem_body
+    problems_df['cleaned body'] = problems_df['Problem Body'].apply(clean_func)
+
+    # Label answer options for multiple-choice items
+    problems_df['answer_options'] = problems_df['Multiple Choice Options'].apply(label_answer_options)
+
+    # Get correct answer letters for multiple-choice, keep original for fill-in
+    problems_df['correct_answers'] = problems_df.apply(
+        lambda row: get_correct_option_letters(row['answer_options'], row['Multiple Choice Answers'])
+        if row['Problem Type'] in ['Multiple Choice (select 1)', 'Multiple Choice (select all)']
+        else row['Fill-in Answers'],
+        axis=1
+    )
+
+    skill_df = pd.read_csv(skill_csv)
+    problems_df = pd.merge(problems_df, skill_df, on='problem_id', how='left')
+
+    # Pre-compute formatted answer options once per problem
+    problems_df['answer_options_formatted'] = problems_df['answer_options'].apply(
+        lambda x: format_answer_options_for_prompt(x) if pd.notna(x) else None
+    )
+
+    # Sort student data by id (chronological order)
+    student_df = student_df.sort_values('id').reset_index(drop=True)
+
+    # Merge with problems data
+    merged_df = student_df.merge(problems_df, on='problem_id', how='inner')
+
+    # Convert student answers to letter format for multiple-choice problems
+    merged_df['answer_text'] = merged_df.apply(
+        lambda row: match_student_answer_to_letters(row['answer_text'], row['answer_options'])
+        if row['Problem Type'] in ['Multiple Choice (select 1)', 'Multiple Choice (select all)'] and pd.notna(row['answer_options'])
+        else row['answer_text'],
+        axis=1
+    )
+
+    # Select users (all or random sample)
+    all_users = merged_df['user_id'].unique()
+    if num_students <= 0:
+        # Use all students
+        selected_users = all_users
+        print(f"\nUsing all {len(all_users)} users")
+    else:
+        # Random sample
+        np.random.seed(42)  # For reproducibility
+        selected_users = np.random.choice(all_users, size=min(num_students, len(all_users)), replace=False)
+        merged_df = merged_df[merged_df['user_id'].isin(selected_users)]
+        print(f"\nSelected {len(selected_users)} random users from {len(all_users)} total users")
+    print(f"Filtered data: {len(merged_df)} rows")
+
+    # Prepare data for batch processing
+    print("\nPreparing prompts in parallel...")
+
+    # Prepare user groups for parallel processing
+    print("Grouping user data...")
+    user_groups = [
+        (user_id, user_df.to_dict('records'), min_history, bin_size)
+        for user_id, user_df in merged_df.groupby('user_id')
+    ]
+    print(f"Processing {len(user_groups)} users with {cpu_count()} CPU cores...")
+
+    # Process users in parallel
+    all_prompts = []
+    all_metadata = []
+
+    with Pool(processes=cpu_count()) as pool:
+        results = list(tqdm(
+            pool.imap(_process_single_user_wrapper, user_groups),
+            total=len(user_groups),
+            desc="Preparing prompts"
+        ))
+
+    # Merge results
+    for prompts, metadata in results:
+        all_prompts.extend(prompts)
+        all_metadata.extend(metadata)
+
+    print(f"\nTotal predictions to make: {len(all_prompts)}")
+
+    # Filter out already-completed predictions (resume support)
+    completed_ids = load_completed_predictions(output_jsonl)
+    remaining = [(p, m) for p, m in zip(all_prompts, all_metadata)
+                 if m['prediction_id'] not in completed_ids]
+
+    if not remaining:
+        print("All predictions already completed!")
+        return
+
+    all_prompts, all_metadata = zip(*remaining)
+    all_prompts = list(all_prompts)
+    all_metadata = list(all_metadata)
+
+    print(f"Already completed: {len(completed_ids)}")
+    print(f"Remaining to process: {len(all_prompts)}")
+    print(f"Processing in batches of {batch_size}")
+
+    # Initialize vLLM engine
+    print("\nInitializing vLLM engine...")
+    sampling_params = SamplingParams(**gen_configs)
+    llm_kwargs = {
+        "model": model_id,
+        "tensor_parallel_size": args.num_gpus,
+        "trust_remote_code": True,
+        "gpu_memory_utilization": args.gpu_memory_utilization,
+        "enable_prefix_caching": True,
+    }
+    if args.max_num_seqs is not None:
+        llm_kwargs["max_num_seqs"] = args.max_num_seqs
+    if args.max_model_len is not None:
+        llm_kwargs["max_model_len"] = args.max_model_len
+    if cache_dir:
+        llm_kwargs["download_dir"] = cache_dir
+    llm = LLM(**llm_kwargs)
+
+    # Process in batches
+    results = []
+    num_batches = (len(all_prompts) + batch_size - 1) // batch_size
+
+    for batch_idx in range(num_batches):
+        batch_start = batch_idx * batch_size
+        batch_end = min(batch_start + batch_size, len(all_prompts))
+
+        batch_prompts = all_prompts[batch_start:batch_end]
+        batch_metadata = all_metadata[batch_start:batch_end]
+
+        print(f"\n{'='*80}")
+        print(f"Processing batch {batch_idx + 1}/{num_batches}")
+        print(f"Items: {batch_start} to {batch_end} ({len(batch_prompts)} prompts)")
+        print(f"{'='*80}")
+
+        # Generate predictions for this batch
+        try:
+            outputs = llm.generate(batch_prompts, sampling_params)
+            response_texts = [o.outputs[0].text.strip() for o in outputs]
+
+            # Process results for this batch
+            batch_results = process_batch(batch_metadata, response_texts)
+            results.extend(batch_results)
+
+            print(f"Successfully processed batch {batch_idx + 1}")
+            print(f"Total results so far: {len(results)}")
+
+            # Append results immediately after each batch
+            append_results_jsonl(batch_results, output_jsonl)
+            print(f"Saved {len(batch_results)} results to {output_jsonl}")
+
+        except Exception as e:
+            print(f"\nERROR processing batch {batch_idx + 1}: {str(e)}")
+            print(f"Progress saved in {output_jsonl} - restart to resume")
+            raise
+
+    print(f"\n{'='*80}")
+    print("All batches processed successfully!")
+    print(f"{'='*80}")
+    print(f"\nAll results saved to {output_jsonl}")
+    print(f"Total predictions processed: {len(results)}")
+
+    # Cleanup
+    print("\nCleaning up...")
+    destroy_model_parallel()
+    destroy_distributed_environment()
+    del llm
+    with contextlib.suppress(AssertionError):
+        torch.distributed.destroy_process_group()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    print("\nDone!")
+    exit(0)

Code/llama33_70b_instruct_vllm.py

@@ -0,0 +1,30 @@
+"""
+Knowledge Tracing inference with Llama-3.3-70B-Instruct model.
+
+Usage:
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python llama33_70b_instruct_vllm.py \
+        --data-dir foundationalktdataset/ \
+        --num-gpus 4 \
+        --batch-size 10 \
+        --cache-dir /data1/ \
+        --num-students 500 \
+        --bin-size 50 \
+        --min-history 50
+"""
+
+from kt_inference_base import run_inference
+
+MODEL_CONFIG = {
+    "model_id": "meta-llama/Llama-3.3-70B-Instruct",
+    "gen_configs": {
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "max_tokens": 32768,
+        "repetition_penalty": 1.0,
+    },
+    "output_prefix": "llama33_70b_instruct",
+    "system_prompt_prefix": "",  # No prefix - standard instruct model
+}
+
+if __name__ == "__main__":
+    run_inference(MODEL_CONFIG)

Code/plot_student_attempt_distribution.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""Plot distribution of student attempts over elapsed time.
+
+This script reads FoundationalASSIST `Interactions.csv`, computes elapsed time
+for each attempt from the student's first attempt, groups attempts into fixed
+time bins, and plots the resulting column distribution.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.ticker import FuncFormatter, MaxNLocator
+
+
+DEFAULT_INTERACTIONS_PATH = (
+    Path(__file__).resolve().parent.parent / "Data" / "Interactions.csv"
+)
+DEFAULT_OUTPUT_PLOT = (
+    Path(__file__).resolve().parent.parent
+    / "Results"
+    / "student_attempt_distribution.png"
+)
+DEFAULT_OUTPUT_COUNTS = (
+    Path(__file__).resolve().parent.parent
+    / "Results"
+    / "student_attempt_distribution_counts.csv"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Compute distribution of attempts over elapsed time from "
+            "Interactions.csv and plot binned columns."
+        )
+    )
+    parser.add_argument(
+        "--interactions-path",
+        type=Path,
+        default=DEFAULT_INTERACTIONS_PATH,
+        help="Path to Interactions.csv.",
+    )
+    parser.add_argument(
+        "--output-plot",
+        type=Path,
+        default=DEFAULT_OUTPUT_PLOT,
+        help="Path to save the output figure.",
+    )
+    parser.add_argument(
+        "--output-counts",
+        type=Path,
+        default=DEFAULT_OUTPUT_COUNTS,
+        help="Path to save binned attempt counts as CSV.",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=None,
+        help="Optional cap on rows after sorting (for quick debugging).",
+    )
+    parser.add_argument(
+        "--bin-time",
+        type=float,
+        default=10.0,
+        help=(
+            "Fixed bin width in minutes. "
+            "For example, --bin-time 10 creates bins [0,10), [10,20), ..."
+        ),
+    )
+    parser.add_argument(
+        "--plot-upper-limit-minutes",
+        type=float,
+        default=None,
+        help=(
+            "Optional upper limit for x-axis in minutes. "
+            "If omitted, uses the full range implied by bins."
+        ),
+    )
+    parser.add_argument(
+        "--student-idx",
+        type=int,
+        default=None,
+        help=(
+            "Optional 0-based index of student to plot. Index is based on "
+            "sorted unique user_id values in the loaded interactions."
+        ),
+    )
+    parser.add_argument(
+        "--log-y",
+        action="store_true",
+        help="Use log scale on y-axis.",
+    )
+    return parser.parse_args()
+
+
+def load_interactions(path: Path, max_rows: int | None = None) -> pd.DataFrame:
+    """Load fields required for student attempt timing analysis."""
+    usecols = ["id", "user_id", "end_time"]
+    df = pd.read_csv(path, usecols=usecols, low_memory=False)
+
+    df["id"] = pd.to_numeric(df["id"], errors="coerce")
+    df["id"] = df["id"].fillna(-1).astype(int)
+    df["user_id"] = df["user_id"].astype("string")
+    df["end_time"] = pd.to_datetime(df["end_time"], errors="coerce", utc=True)
+
+    df = df.dropna(subset=["user_id", "end_time"]).copy()
+    df = df.sort_values(["user_id", "end_time", "id"], kind="mergesort")
+
+    if max_rows is not None:
+        if max_rows <= 0:
+            raise ValueError("--max-rows must be a positive integer.")
+        df = df.head(max_rows).copy()
+
+    return df
+
+
+def select_student_by_index(
+    df: pd.DataFrame,
+    student_idx: int,
+) -> tuple[pd.DataFrame, str, int]:
+    """Select one student's interactions by 0-based index over unique IDs."""
+    student_ids = df["user_id"].drop_duplicates().tolist()
+    total_students = len(student_ids)
+
+    if total_students == 0:
+        raise ValueError("No students found in loaded interactions.")
+    if student_idx < 0 or student_idx >= total_students:
+        raise ValueError(
+            f"--student-idx must be in [0, {total_students - 1}], got {student_idx}."
+        )
+
+    selected_student_id = str(student_ids[student_idx])
+    selected_df = df[df["user_id"] == selected_student_id].copy()
+    return selected_df, selected_student_id, total_students
+
+
+def append_student_id_to_output_path(path: Path, student_id: str) -> Path:
+    """Append a safe student-id suffix to output filename."""
+    safe_id = "".join(
+        ch if ch.isalnum() or ch in ("-", "_") else "_" for ch in student_id
+    )
+    return path.with_name(f"{path.stem}_{safe_id}{path.suffix}")
+
+
+def compute_attempt_elapsed_minutes(df: pd.DataFrame) -> pd.Series:
+    """Compute elapsed minutes of each attempt from student's first attempt."""
+    first_times = df.groupby("user_id", sort=False)["end_time"].transform("min")
+    elapsed_minutes = (df["end_time"] - first_times).dt.total_seconds() / 60.0
+    elapsed_minutes.name = "elapsed_minutes"
+    return elapsed_minutes
+
+
+def build_fixed_width_bin_edges_minutes(
+    valid_elapsed_minutes: pd.Series,
+    bin_time_minutes: float,
+) -> list[float]:
+    """Build fixed-width bin edges from min/max elapsed minutes."""
+    min_elapsed = float(valid_elapsed_minutes.min())
+    max_elapsed = float(valid_elapsed_minutes.max())
+
+    start = bin_time_minutes * math.floor(min_elapsed / bin_time_minutes)
+    end = bin_time_minutes * math.ceil(max_elapsed / bin_time_minutes)
+
+    if math.isclose(start, 0.0, abs_tol=1e-12):
+        start = 0.0
+    if math.isclose(end, start, abs_tol=1e-12):
+        end = start + bin_time_minutes
+
+    n_bins = int(round((end - start) / bin_time_minutes))
+    edges = [start + i * bin_time_minutes for i in range(n_bins + 1)]
+    if edges[-1] <= max_elapsed:
+        edges.append(edges[-1] + bin_time_minutes)
+
+    return edges
+
+
+def format_minutes_tick(value: float, _pos: float) -> str:
+    if value < 60:
+        return f"{value:.0f}m"
+    if value < 1440:
+        return f"{value / 60:.0f}h"
+    return f"{value / 1440:.0f}d"
+
+
+def summarize_attempt_distribution(
+    elapsed_minutes: pd.Series,
+    bin_time_minutes: float,
+) -> pd.DataFrame:
+    valid = elapsed_minutes.dropna().copy()
+    if valid.empty:
+        raise ValueError("No valid elapsed attempt times found.")
+
+    edges = build_fixed_width_bin_edges_minutes(valid, bin_time_minutes)
+    binned = pd.cut(valid, bins=edges, right=False, include_lowest=True)
+    counts = binned.value_counts(sort=False)
+    total_attempts = int(counts.sum())
+    probabilities = (counts / total_attempts).astype(float)
+
+    bin_left = pd.Series(edges[:-1], dtype=float)
+    bin_right = pd.Series(edges[1:], dtype=float)
+    bin_width = bin_right - bin_left
+
+    summary = pd.DataFrame(
+        {
+            "bin_left_min": bin_left.to_numpy(),
+            "bin_right_min": bin_right.to_numpy(),
+            "bin_width_min": bin_width.to_numpy(),
+            "attempt_count": counts.to_numpy(),
+            "probability": probabilities.to_numpy(dtype=float),
+            "percentage": probabilities.to_numpy(dtype=float) * 100.0,
+        }
+    )
+    return summary
+
+
+def plot_distribution(
+    summary_df: pd.DataFrame,
+    output_path: Path,
+    log_y: bool = False,
+    plot_upper_limit_minutes: float | None = None,
+    student_idx: int | None = None,
+) -> None:
+    """Create and save student-attempt distribution columns."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    plt.style.use("seaborn-v0_8-whitegrid")
+    if student_idx is not None:
+        fig, ax = plt.subplots(figsize=(10, 5))
+    else:
+        fig, ax = plt.subplots(figsize=(20, 5))
+
+    left = summary_df["bin_left_min"].to_numpy(dtype=float)
+    width = summary_df["bin_width_min"].to_numpy(dtype=float)
+    counts = summary_df["attempt_count"].to_numpy(dtype=float)
+
+    bars = ax.bar(
+        left,
+        counts,
+        width=width,
+        align="edge",
+        color="#4C78A8",
+        # edgecolor="white",
+        # linewidth=1.0,
+    )
+
+    title = "Distribution of Student Attempts Over Elapsed Time"
+    if student_idx is not None:
+        title = f"{title} (student_idx={student_idx})"
+    ax.set_title(title)
+    ax.set_xlabel("Elapsed Time Since Student's First Attempt")
+    ax.set_ylabel("Number of Attempts")
+
+    x_min = float(left.min())
+    x_max = float((left + width).max())
+    if plot_upper_limit_minutes is not None:
+        x_max = min(x_max, float(plot_upper_limit_minutes))
+    ax.set_xlim(x_min, x_max)
+
+    ax.xaxis.set_major_locator(MaxNLocator(nbins=9))
+    ax.xaxis.set_major_formatter(FuncFormatter(format_minutes_tick))
+    ax.grid(axis="y", alpha=0.25, linewidth=0.8)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    if log_y:
+        ax.set_yscale("log")
+
+    annotate_bars = len(summary_df) <= 40
+    if annotate_bars:
+        for bar, pct in zip(bars, summary_df["percentage"]):
+            if pct < 1.0:
+                continue
+            h = bar.get_height()
+            if h <= 0:
+                continue
+            ax.annotate(
+                f"{pct:.1f}%",
+                xy=(bar.get_x() + bar.get_width() / 2.0, h),
+                xytext=(0, 3),
+                textcoords="offset points",
+                ha="center",
+                va="bottom",
+                fontsize=8,
+            )
+
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=400, bbox_inches="tight")
+    plt.close(fig)
+
+
+def main() -> None:
+    args = parse_args()
+
+    if not args.interactions_path.exists():
+        raise FileNotFoundError(
+            f"Interactions file not found: {args.interactions_path}"
+        )
+    if args.bin_time <= 0:
+        raise ValueError("--bin-time must be a positive number.")
+    if args.plot_upper_limit_minutes is not None and args.plot_upper_limit_minutes <= 0:
+        raise ValueError("--plot-upper-limit-minutes must be a positive number.")
+
+    df = load_interactions(args.interactions_path, max_rows=args.max_rows)
+
+    selected_student_id: str | None = None
+    total_students = int(df["user_id"].nunique())
+    if args.student_idx is not None:
+        df, selected_student_id, total_students = select_student_by_index(
+            df,
+            args.student_idx,
+        )
+
+    output_plot_path = args.output_plot
+    output_counts_path = args.output_counts
+    if selected_student_id is not None:
+        output_plot_path = append_student_id_to_output_path(
+            output_plot_path,
+            selected_student_id,
+        )
+        output_counts_path = append_student_id_to_output_path(
+            output_counts_path,
+            selected_student_id,
+        )
+
+    elapsed_minutes = compute_attempt_elapsed_minutes(df)
+    summary = summarize_attempt_distribution(elapsed_minutes, args.bin_time)
+    output_counts_path.parent.mkdir(parents=True, exist_ok=True)
+    summary.to_csv(output_counts_path, index=False)
+
+    plot_distribution(
+        summary,
+        output_plot_path,
+        log_y=args.log_y,
+        plot_upper_limit_minutes=args.plot_upper_limit_minutes,
+        student_idx=args.student_idx,
+    )
+
+    total_attempts = int(summary["attempt_count"].sum())
+    print("Done.")
+    print(f"Interactions loaded: {len(df):,}")
+    print(f"Students in loaded data: {total_students:,}")
+    if selected_student_id is not None:
+        print(f"Selected student idx: {args.student_idx}")
+        print(f"Selected student id: {selected_student_id}")
+    print(f"Attempts used: {total_attempts:,}")
+    print(f"Bin width (min): {args.bin_time}")
+    print(f"Saved plot: {output_plot_path}")
+    print(f"Saved bin counts: {output_counts_path}")
+
+
+if __name__ == "__main__":
+    main()

Code/plot_timegap_distribution.py

@@ -0,0 +1,484 @@
+#!/usr/bin/env python3
+"""Plot the distribution of time gaps between consecutive student attempts.
+
+This script reads FoundationalASSIST `Interactions.csv`, groups interactions by
+student (`user_id`), computes the time difference between each pair of
+consecutive attempts (`end_time`), discretizes these differences into bins, and
+plots the resulting distribution.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.ticker import FuncFormatter, MaxNLocator
+
+
+DEFAULT_INTERACTIONS_PATH = (
+    Path(__file__).resolve().parent.parent / "Data" / "Interactions.csv"
+)
+DEFAULT_OUTPUT_PLOT = (
+    Path(__file__).resolve().parent.parent / "Results" / "time_gap_distribution.png"
+)
+DEFAULT_OUTPUT_COUNTS = (
+    Path(__file__).resolve().parent.parent
+    / "Results"
+    / "time_gap_distribution_counts.csv"
+)
+CDF_MARKER_MINUTES = 60.0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Compute per-student consecutive-attempt time gaps from "
+            "Interactions.csv and plot their binned distribution."
+        )
+    )
+    parser.add_argument(
+        "--interactions-path",
+        type=Path,
+        default=DEFAULT_INTERACTIONS_PATH,
+        help="Path to Interactions.csv.",
+    )
+    parser.add_argument(
+        "--output-plot",
+        type=Path,
+        default=DEFAULT_OUTPUT_PLOT,
+        help="Path to save the output figure.",
+    )
+    parser.add_argument(
+        "--output-counts",
+        type=Path,
+        default=DEFAULT_OUTPUT_COUNTS,
+        help="Path to save bin counts as CSV.",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=None,
+        help="Optional cap on rows after sorting (for quick debugging).",
+    )
+    parser.add_argument(
+        "--keep-nonpositive-gaps",
+        action="store_true",
+        help=(
+            "Keep zero/negative gaps. By default, only strictly positive "
+            "gaps are used."
+        ),
+    )
+    parser.add_argument(
+        "--log-y",
+        action="store_true",
+        help="Use log scale on y-axis.",
+    )
+    parser.add_argument(
+        "--plot-upper-limit-minutes",
+        type=float,
+        default=None,
+        help=(
+            "Optional upper limit for x-axis in minutes. "
+            "If omitted, uses the full range implied by bins."
+        ),
+    )
+    parser.add_argument(
+        "--bin-time",
+        type=float,
+        default=None,
+        help=(
+            "Optional fixed bin width in minutes. "
+            "For example, --bin-time 10 creates bins [0,10), [10,20), ..."
+        ),
+    )
+    parser.add_argument(
+        "--student-idx",
+        type=int,
+        default=None,
+        help=(
+            "Optional 0-based index of student to plot. Index is based on "
+            "sorted unique user_id values in the loaded interactions."
+        ),
+    )
+    return parser.parse_args()
+
+
+def load_interactions(path: Path, max_rows: int | None = None) -> pd.DataFrame:
+    """Load the minimum columns required for time-gap analysis."""
+    usecols = ["id", "user_id", "end_time"]
+    df = pd.read_csv(path, usecols=usecols, low_memory=False)
+
+    df["id"] = pd.to_numeric(df["id"], errors="coerce")
+    df["id"] = df["id"].fillna(-1).astype(int)
+    df["user_id"] = df["user_id"].astype("string")
+    df["end_time"] = pd.to_datetime(df["end_time"], errors="coerce", utc=True)
+
+    df = df.dropna(subset=["user_id", "end_time"]).copy()
+    df = df.sort_values(["user_id", "end_time", "id"], kind="mergesort")
+
+    if max_rows is not None:
+        if max_rows <= 0:
+            raise ValueError("--max-rows must be a positive integer.")
+        df = df.head(max_rows).copy()
+
+    return df
+
+
+def compute_time_gaps_minutes(df: pd.DataFrame) -> pd.Series:
+    """Compute consecutive attempt gaps per student in minutes."""
+    gaps_seconds = (
+        df.groupby("user_id", sort=False)["end_time"].diff().dt.total_seconds()
+    )
+    return gaps_seconds / 60.0
+
+
+def default_bin_edges_minutes() -> list[float]:
+    """Base minute-scale edges (final open tail may be added from data max)."""
+    return [
+        0.0,
+        1.0,
+        5.0,
+        10.0,
+        30.0,
+        60.0,
+        180.0,
+        720.0,
+        1440.0,
+        4320.0,
+        10080.0,
+    ]
+
+
+def build_bin_edges_minutes(valid: pd.Series) -> list[float]:
+    """Build finite plotting edges so bar widths are proportional on x-axis."""
+    edges = default_bin_edges_minutes()
+    base_tail_start = edges[-1]
+    max_gap = float(valid.max())
+
+    if max_gap > base_tail_start:
+        # Add a finite terminal edge that fully contains the data tail.
+        tail_edge = max(base_tail_start + 60.0, max_gap * 1.05)
+        edges.append(tail_edge)
+
+    return edges
+
+
+def build_fixed_width_bin_edges_minutes(
+    valid: pd.Series, bin_time_minutes: float
+) -> list[float]:
+    """Build fixed-width edges from min/max observed gaps."""
+    min_gap = float(valid.min())
+    max_gap = float(valid.max())
+
+    start = bin_time_minutes * math.floor(min_gap / bin_time_minutes)
+    end = bin_time_minutes * math.ceil(max_gap / bin_time_minutes)
+
+    if math.isclose(start, 0.0, abs_tol=1e-12):
+        start = 0.0
+    if math.isclose(end, start, abs_tol=1e-12):
+        end = start + bin_time_minutes
+
+    n_bins = int(round((end - start) / bin_time_minutes))
+    edges = [start + i * bin_time_minutes for i in range(n_bins + 1)]
+    if edges[-1] <= max_gap:
+        edges.append(edges[-1] + bin_time_minutes)
+
+    return edges
+
+
+def format_bin_bound(minutes: float) -> str:
+    if math.isclose(minutes, round(minutes), abs_tol=1e-9):
+        return str(int(round(minutes)))
+    return f"{minutes:.2f}".rstrip("0").rstrip(".")
+
+
+def make_bin_labels(
+    edges: list[float], open_tail_from: float | None = None
+) -> list[str]:
+    labels: list[str] = []
+    last_idx = len(edges) - 2
+    for idx, (left, right) in enumerate(zip(edges[:-1], edges[1:])):
+        if open_tail_from is not None and idx == last_idx and left >= open_tail_from:
+            labels.append(f">= {format_bin_bound(left)} min")
+        else:
+            labels.append(f"[{format_bin_bound(left)}, {format_bin_bound(right)}) min")
+    return labels
+
+
+def format_minutes_tick(value: float, _pos: float) -> str:
+    if value < 60:
+        return f"{int(round(value))}m"
+
+    if value < 1440:
+        hours = value / 60.0
+        if math.isclose(hours, round(hours), abs_tol=1e-9):
+            return f"{int(round(hours))}h"
+        return f"{hours:.1f}h"
+
+    days = value / 1440.0
+    if math.isclose(days, round(days), abs_tol=1e-9):
+        return f"{int(round(days))}d"
+    return f"{days:.1f}d"
+
+
+def summarize_binned_distribution(
+    gaps_minutes: pd.Series,
+    keep_nonpositive: bool,
+    bin_time_minutes: float | None = None,
+) -> pd.DataFrame:
+    valid = filter_valid_gaps(gaps_minutes, keep_nonpositive)
+
+    if valid.empty:
+        raise ValueError("No valid time gaps found after filtering.")
+
+    if bin_time_minutes is not None:
+        edges = build_fixed_width_bin_edges_minutes(valid, bin_time_minutes)
+        open_tail_from = None
+    else:
+        base_edges = default_bin_edges_minutes()
+        edges = build_bin_edges_minutes(valid)
+        open_tail_from = base_edges[-1] if len(edges) > len(base_edges) else None
+
+    labels = make_bin_labels(edges, open_tail_from=open_tail_from)
+    binned = pd.cut(valid, bins=edges, labels=labels, right=False, include_lowest=True)
+
+    counts = binned.value_counts(sort=False)
+    probabilities = (counts / counts.sum()).astype(float)
+
+    bin_left = pd.Series(edges[:-1], dtype=float)
+    bin_right = pd.Series(edges[1:], dtype=float)
+    bin_width = bin_right - bin_left
+    probabilities_np = probabilities.to_numpy(dtype=float)
+    density_per_min = probabilities_np / bin_width.to_numpy(dtype=float)
+
+    summary = pd.DataFrame(
+        {
+            "bin": counts.index.astype(str),
+            "bin_left_min": bin_left.to_numpy(),
+            "bin_right_min": bin_right.to_numpy(),
+            "bin_width_min": bin_width.to_numpy(),
+            "count": counts.values,
+            "probability": probabilities_np,
+            "percentage": probabilities_np * 100.0,
+            "density_per_min": density_per_min,
+        }
+    )
+    return summary
+
+
+def filter_valid_gaps(gaps_minutes: pd.Series, keep_nonpositive: bool) -> pd.Series:
+    valid = gaps_minutes.dropna().copy()
+    if not keep_nonpositive:
+        valid = valid[valid > 0]
+    return valid
+
+
+def cumulative_probability_at_minutes(
+    gaps_minutes: pd.Series,
+    threshold_minutes: float,
+    keep_nonpositive: bool,
+) -> float:
+    valid = filter_valid_gaps(gaps_minutes, keep_nonpositive)
+    if valid.empty:
+        raise ValueError("No valid time gaps found after filtering.")
+    return float((valid <= threshold_minutes).mean())
+
+
+def select_student_by_index(
+    df: pd.DataFrame,
+    student_idx: int,
+) -> tuple[pd.DataFrame, str, int]:
+    """Select one student's interactions by 0-based index over unique IDs."""
+    student_ids = df["user_id"].drop_duplicates().tolist()
+    total_students = len(student_ids)
+
+    if total_students == 0:
+        raise ValueError("No students found in loaded interactions.")
+    if student_idx < 0 or student_idx >= total_students:
+        raise ValueError(
+            f"--student-idx must be in [0, {total_students - 1}], got {student_idx}."
+        )
+
+    selected_student_id = str(student_ids[student_idx])
+    selected_df = df[df["user_id"] == selected_student_id].copy()
+    return selected_df, selected_student_id, total_students
+
+
+def append_student_id_to_output_path(path: Path, student_id: str) -> Path:
+    """Append a safe student-id suffix to output filename."""
+    safe_id = "".join(
+        ch if ch.isalnum() or ch in ("-", "_") else "_" for ch in student_id
+    )
+    return path.with_name(f"{path.stem}_{safe_id}{path.suffix}")
+
+
+def plot_distribution(
+    summary_df: pd.DataFrame,
+    output_path: Path,
+    log_y: bool = False,
+    plot_upper_limit_minutes: float | None = None,
+    cdf_marker_minutes: float = CDF_MARKER_MINUTES,
+    cdf_at_marker: float | None = None,
+    student_idx: int | None = None,
+) -> None:
+    """Create and save a publication-ready distribution histogram."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    plt.style.use("seaborn-v0_8-whitegrid")
+
+    if student_idx is not None:
+        fig, ax = plt.subplots(figsize=(10, 5))
+    else:
+        fig, ax = plt.subplots(figsize=(20, 5))
+
+    left = summary_df["bin_left_min"].to_numpy(dtype=float)
+    width = summary_df["bin_width_min"].to_numpy(dtype=float)
+    height = summary_df["density_per_min"].to_numpy(dtype=float)
+
+    bars = ax.bar(
+        left,
+        height,
+        width=width,
+        align="edge",
+        color="#4C78A8",
+        # edgecolor="white",
+        # linewidth=1.0,
+    )
+
+    title = "Distribution of Time Gaps Between Consecutive Attempts"
+    if student_idx is not None:
+        title = f"{title} (student_idx={student_idx})"
+    ax.set_title(title)
+    ax.set_xlabel("Time Gap")
+    ax.set_ylabel("Probability Density (1/min)")
+    x_min = float(left.min())
+    x_max = float((left + width).max())
+    if plot_upper_limit_minutes is not None:
+        x_max = min(x_max, float(plot_upper_limit_minutes))
+    ax.set_xlim(x_min, x_max)
+    ax.xaxis.set_major_locator(MaxNLocator(nbins=9))
+    ax.xaxis.set_major_formatter(FuncFormatter(format_minutes_tick))
+    ax.grid(axis="y", alpha=0.25, linewidth=0.8)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    if log_y:
+        ax.set_yscale("log")
+
+    marker_label = f"CDF <= {int(cdf_marker_minutes)} min"
+    if cdf_at_marker is not None:
+        marker_label = f"{marker_label}: {cdf_at_marker * 100:.1f}%"
+    ax.axvline(
+        cdf_marker_minutes,
+        color="#E45756",
+        linestyle="--",
+        linewidth=1.6,
+        label=marker_label,
+    )
+    ax.legend(loc="upper right", frameon=False, fontsize=9)
+
+    # Label non-trivial bins for readability in papers.
+    for bar, pct in zip(bars, summary_df["percentage"]):
+        if pct < 1.0:
+            continue
+        height = bar.get_height()
+        if height <= 0:
+            continue
+        ax.annotate(
+            f"{pct:.1f}%",
+            xy=(bar.get_x() + bar.get_width() / 2.0, height),
+            xytext=(0, 3),
+            textcoords="offset points",
+            ha="center",
+            va="bottom",
+            fontsize=8,
+        )
+
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=400, bbox_inches="tight")
+    plt.close(fig)
+
+
+def main() -> None:
+    args = parse_args()
+
+    if not args.interactions_path.exists():
+        raise FileNotFoundError(
+            f"Interactions file not found: {args.interactions_path}"
+        )
+
+    df = load_interactions(args.interactions_path, max_rows=args.max_rows)
+    selected_student_id: str | None = None
+    total_students = int(df["user_id"].nunique())
+    if args.student_idx is not None:
+        df, selected_student_id, total_students = select_student_by_index(
+            df,
+            args.student_idx,
+        )
+
+    output_plot_path = args.output_plot
+    output_counts_path = args.output_counts
+    if selected_student_id is not None:
+        output_plot_path = append_student_id_to_output_path(
+            output_plot_path,
+            selected_student_id,
+        )
+        output_counts_path = append_student_id_to_output_path(
+            output_counts_path,
+            selected_student_id,
+        )
+
+    gaps_minutes = compute_time_gaps_minutes(df)
+
+    if args.plot_upper_limit_minutes is not None and args.plot_upper_limit_minutes <= 0:
+        raise ValueError("--plot-upper-limit-minutes must be a positive number.")
+    if args.bin_time is not None and args.bin_time <= 0:
+        raise ValueError("--bin-time must be a positive number.")
+
+    summary = summarize_binned_distribution(
+        gaps_minutes,
+        keep_nonpositive=args.keep_nonpositive_gaps,
+        bin_time_minutes=args.bin_time,
+    )
+    output_counts_path.parent.mkdir(parents=True, exist_ok=True)
+    summary.to_csv(output_counts_path, index=False)
+
+    cdf_at_marker = cumulative_probability_at_minutes(
+        gaps_minutes=gaps_minutes,
+        threshold_minutes=CDF_MARKER_MINUTES,
+        keep_nonpositive=args.keep_nonpositive_gaps,
+    )
+
+    plot_distribution(
+        summary,
+        output_plot_path,
+        log_y=args.log_y,
+        plot_upper_limit_minutes=args.plot_upper_limit_minutes,
+        cdf_marker_minutes=CDF_MARKER_MINUTES,
+        cdf_at_marker=cdf_at_marker,
+        student_idx=args.student_idx,
+    )
+
+    total_pairs = int(summary["count"].sum())
+    print("Done.")
+    print(f"Interactions loaded: {len(df):,}")
+    print(f"Students in loaded data: {total_students:,}")
+    if selected_student_id is not None:
+        print(f"Selected student idx: {args.student_idx}")
+        print(f"Selected student id: {selected_student_id}")
+    print(f"Consecutive attempt pairs used: {total_pairs:,}")
+    if args.bin_time is not None:
+        print(f"Bin width (min): {args.bin_time}")
+    print(
+        f"Cumulative P(gap <= {int(CDF_MARKER_MINUTES)} min): "
+        f"{cdf_at_marker * 100:.2f}%"
+    )
+    print(f"Saved plot: {output_plot_path}")
+    print(f"Saved bin counts: {output_counts_path}")
+
+
+if __name__ == "__main__":
+    main()

Code/plot_totaltime_distribution.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""Plot distribution of per-student total time from first to last attempt.
+
+This script reads FoundationalASSIST `Interactions.csv`, groups interactions by
+student (`user_id`), computes each student's total time span from first to last
+recorded attempt (`end_time`), discretizes these totals into bins, and plots
+the resulting distribution.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.ticker import FuncFormatter, MaxNLocator
+
+
+DEFAULT_INTERACTIONS_PATH = (
+    Path(__file__).resolve().parent.parent / "Data" / "Interactions.csv"
+)
+DEFAULT_OUTPUT_PLOT = (
+    Path(__file__).resolve().parent.parent / "Results" / "total_time_distribution.png"
+)
+DEFAULT_OUTPUT_COUNTS = (
+    Path(__file__).resolve().parent.parent
+    / "Results"
+    / "total_time_distribution_counts.csv"
+)
+DEFAULT_CDF_MARKER_MINUTES = 1051200.0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Compute per-student total time (first to last attempt) from "
+            "Interactions.csv and plot the binned distribution."
+        )
+    )
+    parser.add_argument(
+        "--interactions-path",
+        type=Path,
+        default=DEFAULT_INTERACTIONS_PATH,
+        help="Path to Interactions.csv.",
+    )
+    parser.add_argument(
+        "--output-plot",
+        type=Path,
+        default=DEFAULT_OUTPUT_PLOT,
+        help="Path to save the output figure.",
+    )
+    parser.add_argument(
+        "--output-counts",
+        type=Path,
+        default=DEFAULT_OUTPUT_COUNTS,
+        help="Path to save bin counts as CSV.",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=None,
+        help="Optional cap on rows after sorting (for quick debugging).",
+    )
+    parser.add_argument(
+        "--keep-nonpositive-total-times",
+        action="store_true",
+        help=(
+            "Keep zero/negative total times. By default, only strictly "
+            "positive total times are used."
+        ),
+    )
+    parser.add_argument(
+        "--log-y",
+        action="store_true",
+        help="Use log scale on y-axis.",
+    )
+    parser.add_argument(
+        "--plot-upper-limit-minutes",
+        type=float,
+        default=None,
+        help=(
+            "Optional upper limit for x-axis in minutes. "
+            "If omitted, uses the full range implied by bins."
+        ),
+    )
+    parser.add_argument(
+        "--bin-time",
+        type=float,
+        default=None,
+        help=(
+            "Optional fixed bin width in minutes. "
+            "For example, --bin-time 60 creates hourly bins."
+        ),
+    )
+    parser.add_argument(
+        "--cdf-marker-minutes",
+        type=float,
+        default=DEFAULT_CDF_MARKER_MINUTES,
+        help="Threshold (in minutes) for plotting cumulative probability marker.",
+    )
+    return parser.parse_args()
+
+
+def load_interactions(path: Path, max_rows: int | None = None) -> pd.DataFrame:
+    """Load minimum interaction fields required for timing analysis."""
+    usecols = ["id", "user_id", "end_time"]
+    df = pd.read_csv(path, usecols=usecols, low_memory=False)
+
+    df["id"] = pd.to_numeric(df["id"], errors="coerce")
+    df["id"] = df["id"].fillna(-1).astype(int)
+    df["user_id"] = df["user_id"].astype("string")
+    df["end_time"] = pd.to_datetime(df["end_time"], errors="coerce", utc=True)
+
+    df = df.dropna(subset=["user_id", "end_time"]).copy()
+    df = df.sort_values(["user_id", "end_time", "id"], kind="mergesort")
+
+    if max_rows is not None:
+        if max_rows <= 0:
+            raise ValueError("--max-rows must be a positive integer.")
+        df = df.head(max_rows).copy()
+
+    return df
+
+
+def compute_student_total_times_minutes(df: pd.DataFrame) -> pd.Series:
+    """Compute per-student total time span from first to last attempt."""
+    grouped = df.groupby("user_id", sort=False)["end_time"]
+    first_times = grouped.min()
+    last_times = grouped.max()
+    total_minutes = (last_times - first_times).dt.total_seconds() / 60.0
+    total_minutes.name = "total_time_minutes"
+    return total_minutes
+
+
+def default_bin_edges_minutes() -> list[float]:
+    """Base edges for total-time distribution in minutes."""
+    return [
+        0.0,
+        10.0,
+        30.0,
+        60.0,
+        180.0,
+        360.0,
+        720.0,
+        1440.0,
+        2880.0,
+        4320.0,
+        10080.0,
+        20160.0,
+        43200.0,
+        100800.0,
+    ]
+
+
+def build_bin_edges_minutes(valid: pd.Series) -> list[float]:
+    """Build finite plotting edges for proportional-width histogram bars."""
+    edges = default_bin_edges_minutes()
+    base_tail_start = edges[-1]
+    max_total = float(valid.max())
+
+    if max_total > base_tail_start:
+        tail_edge = max(base_tail_start + 60.0, max_total * 1.05)
+        edges.append(tail_edge)
+
+    return edges
+
+
+def build_fixed_width_bin_edges_minutes(
+    valid: pd.Series, bin_time_minutes: float
+) -> list[float]:
+    """Build fixed-width edges from min/max observed total times."""
+    min_total = float(valid.min())
+    max_total = float(valid.max())
+
+    start = bin_time_minutes * math.floor(min_total / bin_time_minutes)
+    end = bin_time_minutes * math.ceil(max_total / bin_time_minutes)
+
+    if math.isclose(start, 0.0, abs_tol=1e-12):
+        start = 0.0
+    if math.isclose(end, start, abs_tol=1e-12):
+        end = start + bin_time_minutes
+
+    n_bins = int(round((end - start) / bin_time_minutes))
+    edges = [start + i * bin_time_minutes for i in range(n_bins + 1)]
+    if edges[-1] <= max_total:
+        edges.append(edges[-1] + bin_time_minutes)
+
+    return edges
+
+
+def format_bin_bound(minutes: float) -> str:
+    if math.isclose(minutes, round(minutes), abs_tol=1e-9):
+        return str(int(round(minutes)))
+    return f"{minutes:.2f}".rstrip("0").rstrip(".")
+
+
+def make_bin_labels(
+    edges: list[float], open_tail_from: float | None = None
+) -> list[str]:
+    labels: list[str] = []
+    last_idx = len(edges) - 2
+    for idx, (left, right) in enumerate(zip(edges[:-1], edges[1:])):
+        if open_tail_from is not None and idx == last_idx and left >= open_tail_from:
+            labels.append(f">= {format_bin_bound(left)} min")
+        else:
+            labels.append(f"[{format_bin_bound(left)}, {format_bin_bound(right)}) min")
+    return labels
+
+
+def format_minutes_tick(value: float, _pos: float) -> str:
+    if value < 60:
+        return f"{value:.0f}m"
+    if value < 1440:
+        return f"{value / 60:.0f}h"
+    return f"{value / 1440:.0f}d"
+
+
+def filter_valid_total_times(
+    total_times_minutes: pd.Series, keep_nonpositive: bool
+) -> pd.Series:
+    valid = total_times_minutes.dropna().copy()
+    if not keep_nonpositive:
+        valid = valid[valid > 0]
+    return valid
+
+
+def summarize_binned_distribution(
+    total_times_minutes: pd.Series,
+    keep_nonpositive: bool,
+    bin_time_minutes: float | None = None,
+) -> pd.DataFrame:
+    valid = filter_valid_total_times(total_times_minutes, keep_nonpositive)
+
+    if valid.empty:
+        raise ValueError("No valid total times found after filtering.")
+
+    if bin_time_minutes is not None:
+        edges = build_fixed_width_bin_edges_minutes(valid, bin_time_minutes)
+        open_tail_from = None
+    else:
+        base_edges = default_bin_edges_minutes()
+        edges = build_bin_edges_minutes(valid)
+        open_tail_from = base_edges[-1] if len(edges) > len(base_edges) else None
+
+    labels = make_bin_labels(edges, open_tail_from=open_tail_from)
+    binned = pd.cut(valid, bins=edges, labels=labels, right=False, include_lowest=True)
+
+    counts = binned.value_counts(sort=False)
+    probabilities = (counts / counts.sum()).astype(float)
+
+    bin_left = pd.Series(edges[:-1], dtype=float)
+    bin_right = pd.Series(edges[1:], dtype=float)
+    bin_width = bin_right - bin_left
+    probabilities_np = probabilities.to_numpy(dtype=float)
+    density_per_min = probabilities_np / bin_width.to_numpy(dtype=float)
+
+    summary = pd.DataFrame(
+        {
+            "bin": counts.index.astype(str),
+            "bin_left_min": bin_left.to_numpy(),
+            "bin_right_min": bin_right.to_numpy(),
+            "bin_width_min": bin_width.to_numpy(),
+            "count": counts.values,
+            "probability": probabilities_np,
+            "percentage": probabilities_np * 100.0,
+            "density_per_min": density_per_min,
+        }
+    )
+    return summary
+
+
+def cumulative_probability_at_minutes(
+    total_times_minutes: pd.Series,
+    threshold_minutes: float,
+    keep_nonpositive: bool,
+) -> float:
+    valid = filter_valid_total_times(total_times_minutes, keep_nonpositive)
+    if valid.empty:
+        raise ValueError("No valid total times found after filtering.")
+    return float((valid <= threshold_minutes).mean())
+
+
+def plot_distribution(
+    summary_df: pd.DataFrame,
+    output_path: Path,
+    log_y: bool = False,
+    plot_upper_limit_minutes: float | None = None,
+    cdf_marker_minutes: float = DEFAULT_CDF_MARKER_MINUTES,
+    cdf_at_marker: float | None = None,
+) -> None:
+    """Create and save a publication-ready total-time distribution histogram."""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    plt.style.use("seaborn-v0_8-whitegrid")
+
+    fig, ax = plt.subplots(figsize=(20, 5))
+
+    left = summary_df["bin_left_min"].to_numpy(dtype=float)
+    width = summary_df["bin_width_min"].to_numpy(dtype=float)
+    height = summary_df["density_per_min"].to_numpy(dtype=float)
+
+    bars = ax.bar(
+        left,
+        height,
+        width=width,
+        align="edge",
+        color="#4C78A8",
+        # edgecolor="white",
+        # linewidth=1.0,
+    )
+
+    ax.set_title("Distribution of Student Total Time (First to Last Attempt)")
+    ax.set_xlabel("Total Time Per Student")
+    ax.set_ylabel("Probability Density (1/min)")
+
+    x_min = float(left.min())
+    x_max = float((left + width).max())
+    if plot_upper_limit_minutes is not None:
+        x_max = min(x_max, float(plot_upper_limit_minutes))
+    ax.set_xlim(x_min, x_max)
+
+    ax.xaxis.set_major_locator(MaxNLocator(nbins=9))
+    ax.xaxis.set_major_formatter(FuncFormatter(format_minutes_tick))
+    ax.grid(axis="y", alpha=0.25, linewidth=0.8)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    if log_y:
+        ax.set_yscale("log")
+
+    marker_label = f"CDF <= {format_bin_bound(cdf_marker_minutes)} min"
+    if cdf_at_marker is not None:
+        marker_label = f"{marker_label}: {cdf_at_marker * 100:.1f}%"
+    ax.axvline(
+        cdf_marker_minutes,
+        color="#E45756",
+        linestyle="--",
+        linewidth=1.6,
+        label=marker_label,
+    )
+    ax.legend(loc="upper right", frameon=False, fontsize=9)
+
+    # Skip dense labeling when there are many bins to keep figure readable.
+    annotate_bars = len(summary_df) <= 40
+    if annotate_bars:
+        for bar, pct in zip(bars, summary_df["percentage"]):
+            if pct < 1.0:
+                continue
+            h = bar.get_height()
+            if h <= 0:
+                continue
+            ax.annotate(
+                f"{pct:.1f}%",
+                xy=(bar.get_x() + bar.get_width() / 2.0, h),
+                xytext=(0, 3),
+                textcoords="offset points",
+                ha="center",
+                va="bottom",
+                fontsize=8,
+            )
+
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=400, bbox_inches="tight")
+    plt.close(fig)
+
+
+def main() -> None:
+    args = parse_args()
+
+    if not args.interactions_path.exists():
+        raise FileNotFoundError(
+            f"Interactions file not found: {args.interactions_path}"
+        )
+
+    if args.plot_upper_limit_minutes is not None and args.plot_upper_limit_minutes <= 0:
+        raise ValueError("--plot-upper-limit-minutes must be a positive number.")
+    if args.bin_time is not None and args.bin_time <= 0:
+        raise ValueError("--bin-time must be a positive number.")
+    if args.cdf_marker_minutes <= 0:
+        raise ValueError("--cdf-marker-minutes must be a positive number.")
+
+    df = load_interactions(args.interactions_path, max_rows=args.max_rows)
+    total_times_minutes = compute_student_total_times_minutes(df)
+
+    summary = summarize_binned_distribution(
+        total_times_minutes,
+        keep_nonpositive=args.keep_nonpositive_total_times,
+        bin_time_minutes=args.bin_time,
+    )
+    summary.to_csv(args.output_counts, index=False)
+
+    cdf_at_marker = cumulative_probability_at_minutes(
+        total_times_minutes=total_times_minutes,
+        threshold_minutes=args.cdf_marker_minutes,
+        keep_nonpositive=args.keep_nonpositive_total_times,
+    )
+
+    plot_distribution(
+        summary,
+        args.output_plot,
+        log_y=args.log_y,
+        plot_upper_limit_minutes=args.plot_upper_limit_minutes,
+        cdf_marker_minutes=args.cdf_marker_minutes,
+        cdf_at_marker=cdf_at_marker,
+    )
+
+    total_students = int(df["user_id"].nunique())
+    students_used = int(
+        len(
+            filter_valid_total_times(
+                total_times_minutes,
+                keep_nonpositive=args.keep_nonpositive_total_times,
+            )
+        )
+    )
+    print("Done.")
+    print(f"Interactions loaded: {len(df):,}")
+    print(f"Students observed: {total_students:,}")
+    print(f"Students used in distribution: {students_used:,}")
+    if args.bin_time is not None:
+        print(f"Bin width (min): {args.bin_time}")
+    print(
+        f"Cumulative P(total_time <= {format_bin_bound(args.cdf_marker_minutes)} min): "
+        f"{cdf_at_marker * 100:.2f}%"
+    )
+    print(f"Saved plot: {args.output_plot}")
+    print(f"Saved bin counts: {args.output_counts}")
+
+
+if __name__ == "__main__":
+    main()

Code/process_to_single_file.py

@@ -0,0 +1,820 @@
+#!/usr/bin/env python3
+"""
+Convert FoundationalASSIST CSV files to the CSEDM/OEKT JSON format.
+
+Inputs (under Data/ by default):
+    - Interactions.csv
+    - Problems.csv
+    - Skill_Set.csv
+    - Skills.csv
+
+Outputs (under src/data/FoundationalASSIST/ by default):
+    - dataset.json
+    - qmatrix.json
+    - trainset.json
+    - validset.json
+    - testset.json
+
+The produced dataset JSON follows the same schema used by src/data/CSEDM.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+from pathlib import Path
+from typing import Literal, cast
+
+import pandas as pd
+from tqdm import tqdm
+from clean_utils import clean_problem_body
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+DEFAULT_DATA_DIR = Path(__file__).resolve().parent.parent / "Data"
+DEFAULT_OUTPUT_DIR = PROJECT_ROOT / "src" / "data" / "FoundationalASSIST"
+GroupingMode = Literal["none", "1h", "halfday", "day", "week", "month", "year"]
+
+
+def parse_grouping_mode(value: str) -> GroupingMode:
+    """Normalize grouping mode aliases used by --grouping-time."""
+    normalized = value.strip().lower()
+    aliases: dict[str, GroupingMode] = {
+        "0": "none",
+        "0.0": "none",
+        "none": "none",
+        "off": "none",
+        "no": "none",
+        "1h": "1h",
+        "hour": "1h",
+        "halfday": "halfday",
+        "half-day": "halfday",
+        "day": "day",
+        "week": "week",
+        "month": "month",
+        "year": "year",
+    }
+    mode = aliases.get(normalized)
+    if mode is None:
+        valid_values = "1h, halfday, day, week, month, year, none"
+        raise argparse.ArgumentTypeError(
+            f"Invalid grouping mode '{value}'. Valid values: {valid_values}."
+        )
+    return mode
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Convert FoundationalASSIST to CSEDM/OEKT JSON format."
+    )
+    parser.add_argument(
+        "--data-dir",
+        type=Path,
+        default=DEFAULT_DATA_DIR,
+        help="Directory containing Interactions.csv, Problems.csv, Skills.csv.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help="Directory to write dataset.json/qmatrix.json/split files.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used for train/valid/test student split.",
+    )
+    parser.add_argument(
+        "--train-ratio",
+        type=float,
+        default=0.8,
+        help="Fraction of students in train split.",
+    )
+    parser.add_argument(
+        "--valid-ratio",
+        type=float,
+        default=0.1,
+        help="Fraction of students in valid split.",
+    )
+    parser.add_argument(
+        "--test-ratio",
+        type=float,
+        default=0.1,
+        help="Fraction of students in test split.",
+    )
+    parser.add_argument(
+        "--max-interactions",
+        type=int,
+        default=None,
+        help=(
+            "Optional cap on number of interaction rows after sorting. "
+            "Useful for quick smoke tests."
+        ),
+    )
+    parser.add_argument(
+        "--grouping-time",
+        type=parse_grouping_mode,
+        default="none",
+        help=(
+            "Calendar grouping mode per student: 1h, halfday, day, week, "
+            "month, year, or none."
+        ),
+    )
+    return parser.parse_args()
+
+
+def _text(v: object) -> str:
+    if v is None:
+        return ""
+    if v is pd.NA:
+        return ""
+    if isinstance(v, float) and pd.isna(v):
+        return ""
+    return str(v)
+
+
+def _as_int(v: object) -> int:
+    return int(float(_text(v)))
+
+
+def _as_float(v: object) -> float:
+    return float(_text(v))
+
+
+def label_answer_options(answer_string: object) -> dict[str, str] | None:
+    """Convert pipe-delimited answers to lettered format."""
+    answer_text = _text(answer_string).strip()
+    if not answer_text:
+        return None
+
+    options = [opt.strip() for opt in answer_text.split("||")]
+    letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
+    return {letters[i]: opt for i, opt in enumerate(options) if i < len(letters)}
+
+
+def clean_html_and_normalize(text: object) -> str:
+    """Remove HTML tags and normalize text for reliable comparisons."""
+    normalized = _text(text)
+    if not normalized:
+        return ""
+
+    normalized = re.sub(r"<[^>]+>", "", normalized)
+    normalized = " ".join(normalized.split())
+    normalized = re.sub(r"\s*:\s*", ":", normalized)
+    return normalized.strip()
+
+
+def match_student_answer_to_letters(
+    student_answer_text: object,
+    answer_options_dict: dict[str, str] | None,
+) -> str:
+    """Map student multiple-choice answer text(s) to letter labels."""
+    answer_text = _text(student_answer_text)
+    if not answer_text or not answer_options_dict:
+        return answer_text
+
+    student_answers = [ans.strip() for ans in answer_text.split(" , ")]
+    normalized_options = {
+        letter: clean_html_and_normalize(text)
+        for letter, text in answer_options_dict.items()
+    }
+
+    matched_letters: list[str] = []
+    for student_ans in student_answers:
+        normalized_student = clean_html_and_normalize(student_ans)
+
+        for letter, normalized_option in normalized_options.items():
+            if normalized_student == normalized_option:
+                matched_letters.append(letter)
+                break
+        else:
+            for letter, normalized_option in normalized_options.items():
+                if (
+                    normalized_student in normalized_option
+                    or normalized_option in normalized_student
+                ):
+                    matched_letters.append(letter)
+                    break
+
+    if matched_letters:
+        return ", ".join(sorted(set(matched_letters)))
+    return answer_text
+
+
+def get_correct_option_letters(
+    answer_options: dict[str, str] | None,
+    correct_answers: object,
+) -> str:
+    """Resolve the correct answer text(s) to option letters for MC items."""
+    correct_answer_text = _text(correct_answers).strip()
+    if not answer_options or not correct_answer_text:
+        return correct_answer_text
+
+    correct_list = [ans.strip() for ans in correct_answer_text.split("||")]
+    correct_letters = [
+        letter for letter, text in answer_options.items() if text in correct_list
+    ]
+    return (
+        ", ".join(sorted(correct_letters)) if correct_letters else correct_answer_text
+    )
+
+
+def format_answer_options_for_prompt(answer_options: dict[str, str] | None) -> str:
+    """Format answer options dictionary for human-readable prompt text."""
+    if not answer_options:
+        return ""
+    return "\n".join([f"{letter}) {text}" for letter, text in answer_options.items()])
+
+
+def load_and_preprocess_problems(problems_path: Path) -> pd.DataFrame:
+    """Load and preprocess problems with the same answer handling as KT inference."""
+    problems_df = pd.read_csv(problems_path, low_memory=False)
+    problems_df["problem_id"] = pd.to_numeric(
+        problems_df["problem_id"], errors="coerce"
+    )
+    problems_df = problems_df.dropna(subset=["problem_id"]).copy()
+    problems_df["problem_id"] = problems_df["problem_id"].astype(int)
+
+    problems_df = problems_df.sort_values(["problem_id"]).drop_duplicates(
+        subset=["problem_id"], keep="first"
+    )
+
+    problems_df["cleaned body"] = problems_df["Problem Body"].apply(clean_problem_body)
+    problems_df["answer_options"] = problems_df["Multiple Choice Options"].apply(
+        label_answer_options
+    )
+
+    mc_types = {"Multiple Choice (select 1)", "Multiple Choice (select all)"}
+    problems_df["correct_answers"] = problems_df.apply(
+        lambda row: (
+            get_correct_option_letters(
+                row["answer_options"],
+                row["Multiple Choice Answers"],
+            )
+            if _text(row["Problem Type"]).strip() in mc_types
+            else _text(row.get("Fill-in Answers", ""))
+        ),
+        axis=1,
+    )
+    problems_df["answer_options_formatted"] = problems_df["answer_options"].apply(
+        format_answer_options_for_prompt
+    )
+    return problems_df
+
+
+def load_skill_tables(
+    skills_path: Path,
+    skill_set_path: Path,
+) -> tuple[list[dict], dict[int, list[int]], int]:
+    """Load skills and build a problem_id -> skill_ids mapping.
+
+    Returns:
+        skills: OEKT skill list.
+        problem_to_skills: Mapping from original problem_id to contiguous skill IDs.
+        fallback_skill_id: Skill ID for untagged problems.
+    """
+    usecols = ["problem_id", "node_code", "node_name"]
+    skills_df = pd.read_csv(skills_path, usecols=usecols, low_memory=False)
+
+    skills_df["problem_id"] = pd.to_numeric(skills_df["problem_id"], errors="coerce")
+    skills_df = skills_df.dropna(subset=["problem_id"]).copy()
+    skills_df["problem_id"] = skills_df["problem_id"].astype(int)
+    skills_df["node_code"] = skills_df["node_code"].apply(lambda v: _text(v).strip())
+    skills_df["node_name"] = skills_df["node_name"].apply(lambda v: _text(v).strip())
+    skills_df = skills_df[skills_df["node_code"] != ""].copy()
+
+    skill_set_df = pd.read_csv(
+        skill_set_path,
+        usecols=["index", "skill_code", "full_description"],
+        low_memory=False,
+    )
+    skill_set_df["index"] = pd.to_numeric(skill_set_df["index"], errors="coerce")
+    skill_set_df = skill_set_df.dropna(subset=["index"]).copy()
+    skill_set_df["index"] = skill_set_df["index"].astype(int)
+    skill_set_df["skill_code"] = skill_set_df["skill_code"].apply(
+        lambda v: _text(v).strip()
+    )
+    skill_set_df["full_description"] = skill_set_df["full_description"].apply(
+        lambda v: _text(v).strip()
+    )
+    skill_set_df = skill_set_df[skill_set_df["skill_code"] != ""].copy()
+    skill_set_df = (
+        skill_set_df.sort_values(["index", "skill_code"])
+        .drop_duplicates(subset=["skill_code"], keep="first")
+        .copy()
+    )
+
+    node_name_by_code = (
+        skills_df.sort_values(["node_code", "node_name"])
+        .drop_duplicates(subset=["node_code"], keep="first")
+        .set_index("node_code")["node_name"]
+        .to_dict()
+    )
+
+    skill_rows: list[tuple[str, int, str, str]] = []
+    skill_id_map: dict[str, int] = {}
+    for row in skill_set_df.itertuples(index=False):
+        node_code = _text(row.skill_code).strip()
+        skill_id = _as_int(row.index) - 1
+        skill_id_map[node_code] = skill_id
+
+        node_name = _text(node_name_by_code.get(node_code, "")).strip()
+        name = node_name if node_name else node_code
+        description = _text(row.full_description).strip()
+        if not description:
+            print(
+                f"Warning: Missing description for skill '{node_code}' in Skill_Set.csv. "
+                f"Using default description."
+            )
+
+            description = (
+                f"Common Core State StandardS for Mathematics: Skill {node_code}"
+            )
+
+        skill_rows.append((node_code, skill_id, name, description))
+
+    # max_skill_id = max(skill_id_map.values(), default=-1)
+    missing_node_codes = sorted(
+        set(skills_df["node_code"].tolist()) - set(skill_id_map)
+    )
+    # for node_code in missing_node_codes:
+    #     max_skill_id += 1
+    #     skill_id_map[node_code] = max_skill_id
+
+    #     node_name = _text(node_name_by_code.get(node_code, "")).strip()
+    #     name = node_name if node_name else node_code
+    #     description = (
+    #         node_name
+    #         if node_name
+    #         else f"Common Core State StandardS for Mathematics: Skill {node_code}"
+    #     )
+
+    #     skill_rows.append((node_code, max_skill_id, name, description))
+
+    if missing_node_codes:
+        raise ValueError(
+            f"Error: Found {len(missing_node_codes)} node_code(s) in Skills.csv that are missing from Skill_Set.csv. "
+            f"Please ensure all node_code values in Skills.csv have a corresponding skill_code in Skill_Set.csv. "
+            f"Missing node_codes: {missing_node_codes}"
+        )
+
+    skills: list[dict] = []
+    for _, skill_id, name, description in sorted(skill_rows, key=lambda r: r[0]):
+        skills.append(
+            {
+                "id": skill_id,
+                "name": name,
+                "description": description,
+                "prerequisites": [],
+            }
+        )
+
+    fallback_skill_id = max([s["id"] for s in skills], default=-1) + 1
+    skills.append(
+        {
+            "id": fallback_skill_id,
+            "name": "UnmappedSkill",
+            "description": "Fallback skill for questions without explicit skill tags.",
+            "prerequisites": [],
+        }
+    )
+
+    problem_to_skills: dict[int, list[int]] = {}
+    pairs = skills_df[["problem_id", "node_code"]].drop_duplicates()
+    for row in pairs.itertuples(index=False):
+        pid = _as_int(row.problem_id)
+        sid = skill_id_map[_text(row.node_code).strip()]
+        problem_to_skills.setdefault(pid, []).append(sid)
+
+    for pid, sids in problem_to_skills.items():
+        if len(sids) == 0:
+            print(f"Warning: Problem {pid} has no valid skill mappings.")
+        problem_to_skills[pid] = sorted(set(sids))
+
+    return skills, problem_to_skills, fallback_skill_id
+
+
+def build_question_content(problem_row: pd.Series) -> tuple[str, str]:
+    """Create question content and canonical correct answer from preprocessed fields."""
+    body = _text(problem_row.get("cleaned body", "")).strip()
+    problem_type = _text(problem_row.get("Problem Type", "")).strip()
+    answer_options_formatted = _text(
+        problem_row.get("answer_options_formatted", "")
+    ).strip()
+    correct_answer = _text(problem_row.get("correct_answers", "")).strip()
+
+    body_parts: list[str] = []
+    if body:
+        body_parts.append(body)
+    if problem_type:
+        body_parts.append(f"Problem Type: {problem_type}")
+    if answer_options_formatted:
+        body_parts.append(f"Answer Options:\n{answer_options_formatted}")
+
+    if not body_parts:
+        problem_id = problem_row.get("problem_id", "unknown")
+        return f"Problem {problem_id}", correct_answer
+
+    return "\n\n".join(body_parts), correct_answer
+
+
+def load_questions(
+    problems_df: pd.DataFrame,
+    problem_to_skills: dict[int, list[int]],
+    fallback_skill_id: int,
+) -> tuple[list[dict], dict[int, str], int]:
+    """Build OEKT question objects from preprocessed Problems data."""
+
+    questions: list[dict] = []
+    problem_to_qid: dict[int, str] = {}
+    unmapped_questions = 0
+
+    for row in problems_df.to_dict(orient="records"):
+        pid = _as_int(row["problem_id"])
+        qid = f"q_{pid}"
+        skill_ids = problem_to_skills.get(pid, [])
+        if not skill_ids:
+            skill_ids = [fallback_skill_id]
+            unmapped_questions += 1
+        content, correct_answer = build_question_content(pd.Series(row))
+        question = {
+            "id": qid,
+            "content": content,
+            "skill_ids": skill_ids,
+            "rubrics": [
+                {
+                    "id": f"r_{pid}_0",
+                    "description": (f"Match the correct answer: {correct_answer}"),
+                    "skill_ids": skill_ids,
+                }
+            ],
+        }
+
+        questions.append(question)
+        problem_to_qid[pid] = qid
+
+    return questions, problem_to_qid, unmapped_questions
+
+
+def load_interactions(
+    interactions_path: Path,
+    problem_meta_df: pd.DataFrame,
+    max_interactions: int | None = None,
+) -> pd.DataFrame:
+    """Load and normalize interaction logs used to build student trajectories."""
+    usecols = [
+        "id",
+        "problem_id",
+        "answer_text",
+        "discrete_score",
+        "end_time",
+        "user_id",
+    ]
+    df = pd.read_csv(interactions_path, usecols=usecols, low_memory=False)
+
+    df["problem_id"] = pd.to_numeric(df["problem_id"], errors="coerce")
+    df["discrete_score"] = pd.to_numeric(df["discrete_score"], errors="coerce")
+    df["id"] = pd.to_numeric(df["id"], errors="coerce")
+    df["end_time"] = pd.to_datetime(df["end_time"], errors="coerce", utc=True)
+
+    df = df.dropna(subset=["user_id", "problem_id", "discrete_score"]).copy()
+    df["user_id"] = df["user_id"].astype(str)
+    df["problem_id"] = df["problem_id"].astype(int)
+    df["id"] = df["id"].fillna(-1).astype(int)
+
+    answer_meta = problem_meta_df[
+        ["problem_id", "Problem Type", "answer_options"]
+    ].copy()
+    df = df.merge(answer_meta, on="problem_id", how="left")
+
+    mc_types = {"Multiple Choice (select 1)", "Multiple Choice (select all)"}
+    df["answer_text"] = df.apply(
+        lambda row: (
+            match_student_answer_to_letters(row["answer_text"], row["answer_options"])
+            if _text(row.get("Problem Type", "")).strip() in mc_types
+            and isinstance(row.get("answer_options"), dict)
+            else _text(row["answer_text"])
+        ),
+        axis=1,
+    )
+
+    df = df.drop(columns=["Problem Type", "answer_options"])
+
+    df = df.sort_values(["user_id", "end_time", "id"], kind="mergesort")
+    if max_interactions is not None:
+        if max_interactions <= 0:
+            raise ValueError("--max-interactions must be a positive integer.")
+        df = df.head(max_interactions).copy()
+    return df
+
+
+def build_qmatrix(questions: list[dict], num_skills: int) -> list[list[float]]:
+    """Build a rubric x skill matrix consistent with question/rubric ordering."""
+    qmatrix: list[list[float]] = []
+    for question in questions:
+        for rubric in question["rubrics"]:
+            row = [0.0] * num_skills
+            for sid in rubric["skill_ids"]:
+                row[int(sid)] = 1.0
+            qmatrix.append(row)
+    return qmatrix
+
+
+def split_student_ids(
+    student_ids: list[str],
+    train_ratio: float,
+    valid_ratio: float,
+    test_ratio: float,
+    seed: int,
+) -> tuple[list[str], list[str], list[str]]:
+    """Create deterministic train/valid/test split lists at the student level."""
+    if train_ratio < 0 or valid_ratio < 0 or test_ratio < 0:
+        raise ValueError("Split ratios must be non-negative.")
+
+    total = train_ratio + valid_ratio + test_ratio
+    if total <= 0:
+        raise ValueError("At least one split ratio must be > 0.")
+
+    ids = list(student_ids)
+    ids.sort()
+    rng = random.Random(seed)
+    rng.shuffle(ids)
+
+    train_count = int(len(ids) * (train_ratio / total))
+    valid_count = int(len(ids) * (valid_ratio / total))
+
+    train_ids = ids[:train_count]
+    valid_ids = ids[train_count : train_count + valid_count]
+    test_ids = ids[train_count + valid_count :]
+    return train_ids, valid_ids, test_ids
+
+
+def get_calendar_group_key(
+    end_time: pd.Timestamp | None,
+    grouping_mode: GroupingMode,
+    missing_idx: int,
+) -> tuple[object, ...]:
+    """Return a stable calendar bucket key for an interaction timestamp."""
+    if end_time is None:
+        return ("missing", missing_idx)
+
+    ts = end_time
+    if ts.tzinfo is None:
+        ts = ts.tz_localize("UTC")
+    else:
+        ts = ts.tz_convert("UTC")
+
+    if grouping_mode == "1h":
+        return ("1h", ts.year, ts.month, ts.day, ts.hour)
+    if grouping_mode == "halfday":
+        return ("halfday", ts.year, ts.month, ts.day, 0 if ts.hour < 12 else 1)
+    if grouping_mode == "day":
+        return ("day", ts.year, ts.month, ts.day)
+    if grouping_mode == "week":
+        iso = ts.isocalendar()
+        return ("week", int(iso.year), int(iso.week))
+    if grouping_mode == "month":
+        return ("month", ts.year, ts.month)
+    if grouping_mode == "year":
+        return ("year", ts.year)
+
+    raise ValueError(f"Unsupported grouping mode: {grouping_mode}")
+
+
+def write_dataset_json(
+    dataset_path: Path,
+    skills: list[dict],
+    questions: list[dict],
+    interactions_df: pd.DataFrame,
+    problem_to_qid: dict[int, str],
+    grouping_mode: GroupingMode = "none",
+    save_unmapped_skills: bool = False,
+) -> tuple[list[str], int, int, int, int]:
+    """Stream-write dataset.json while optionally grouping by calendar buckets."""
+    dataset_path.parent.mkdir(parents=True, exist_ok=True)
+
+    student_ids: list[str] = []
+    num_students = 0
+    num_time_steps = 0
+    num_questions = 0
+    skipped_interactions = 0
+
+    with open(dataset_path, "w", encoding="utf-8") as f:
+        f.write("{")
+        f.write('"skills":')
+        if not save_unmapped_skills:
+            saving_skills = (
+                skills[:-1]
+                if skills and skills[-1]["name"] == "UnmappedSkill"
+                else skills
+            )
+        else:
+            saving_skills = skills
+        json.dump(saving_skills, f, ensure_ascii=False)
+        f.write(',"questions":')
+        json.dump(questions, f, ensure_ascii=False)
+        f.write(',"students":[')
+
+        first_student = True
+        for user_id, student_df in tqdm(interactions_df.groupby("user_id", sort=False)):
+            time_steps: list[dict] = []
+            current_group_key: tuple[object, ...] | None = None
+
+            for row_idx, row in enumerate(student_df.itertuples(index=False)):
+                pid = _as_int(row.problem_id)
+                qid = problem_to_qid.get(pid)
+                if qid is None:
+                    skipped_interactions += 1
+                    continue
+
+                score = 1 if _as_float(row.discrete_score) >= 1.0 else 0
+                answer_text = _text(row.answer_text)
+                response = {
+                    "question_id": qid,
+                    "answer_text": answer_text,
+                    "rubric_scores": [score],
+                }
+                num_questions += 1
+
+                if grouping_mode == "none":
+                    time_steps.append(
+                        {
+                            "t": len(time_steps),
+                            "responses": [response],
+                        }
+                    )
+                    continue
+
+                row_end_time_raw = row.end_time
+                row_end_time: pd.Timestamp | None = (
+                    None
+                    if pd.isna(row_end_time_raw)
+                    else cast(pd.Timestamp, row_end_time_raw)
+                )
+
+                group_key = get_calendar_group_key(
+                    end_time=row_end_time,
+                    grouping_mode=grouping_mode,
+                    missing_idx=row_idx,
+                )
+                if time_steps and current_group_key == group_key:
+                    time_steps[-1]["responses"].append(response)
+                    continue
+
+                time_steps.append(
+                    {
+                        "t": len(time_steps),
+                        "responses": [response],
+                    }
+                )
+                current_group_key = group_key
+
+            if not time_steps:
+                continue
+
+            student_obj = {
+                "student_id": user_id,
+                "time_steps": time_steps,
+            }
+
+            if not first_student:
+                f.write(",")
+            json.dump(student_obj, f, ensure_ascii=False)
+            first_student = False
+
+            student_ids.append(str(user_id))
+            num_students += 1
+            num_time_steps += len(time_steps)
+
+        f.write("]}")
+
+    return (
+        student_ids,
+        num_students,
+        num_time_steps,
+        num_questions,
+        skipped_interactions,
+    )
+
+
+def save_json(path: Path, obj: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(obj, f, indent=2, ensure_ascii=False)
+
+
+def main() -> None:
+    args = parse_args()
+
+    data_dir = args.data_dir
+    output_dir = args.output_dir
+
+    interactions_path = data_dir / "Interactions.csv"
+    problems_path = data_dir / "Problems.csv"
+    skill_set_path = data_dir / "Skill_Set.csv"
+    skills_path = data_dir / "Skills.csv"
+
+    for p in [interactions_path, problems_path, skill_set_path, skills_path]:
+        if not p.exists():
+            raise FileNotFoundError(f"Required input file not found: {p}")
+
+    print("Loading skills...")
+    skills, problem_to_skills, fallback_skill_id = load_skill_tables(
+        skills_path=skills_path,
+        skill_set_path=skill_set_path,
+    )
+
+    print("Loading and preprocessing problems...")
+    problems_df = load_and_preprocess_problems(problems_path)
+
+    print("Loading questions...")
+    questions, problem_to_qid, unmapped_questions = load_questions(
+        problems_df=problems_df,
+        problem_to_skills=problem_to_skills,
+        fallback_skill_id=fallback_skill_id,
+    )
+
+    print("Loading interactions...")
+    interactions_df = load_interactions(
+        interactions_path,
+        problem_meta_df=problems_df,
+        max_interactions=args.max_interactions,
+    )
+
+    print("Writing dataset.json...")
+    dataset_path = output_dir / "dataset.json"
+    (
+        student_ids,
+        num_students,
+        num_time_steps,
+        num_questions,
+        skipped_interactions,
+    ) = write_dataset_json(
+        dataset_path=dataset_path,
+        skills=skills,
+        questions=questions,
+        interactions_df=interactions_df,
+        problem_to_qid=problem_to_qid,
+        grouping_mode=args.grouping_time,
+        save_unmapped_skills=(unmapped_questions > 0),
+    )
+
+    print("Building qmatrix.json...")
+    num_skills = len(skills) - int(unmapped_questions == 0)
+    qmatrix = build_qmatrix(questions, num_skills=num_skills)
+    save_json(output_dir / "qmatrix.json", qmatrix)
+
+    print("Building train/valid/test split files...")
+    train_ids, valid_ids, test_ids = split_student_ids(
+        student_ids=student_ids,
+        train_ratio=args.train_ratio,
+        valid_ratio=args.valid_ratio,
+        test_ratio=args.test_ratio,
+        seed=args.seed,
+    )
+    save_json(output_dir / "trainset.json", train_ids)
+    save_json(output_dir / "validset.json", valid_ids)
+    save_json(output_dir / "testset.json", test_ids)
+
+    total_rubrics = sum(len(q["rubrics"]) for q in questions)
+    question_skill_counts = [len(q.get("skill_ids", [])) for q in questions]
+    rubric_skill_counts = [
+        len(r.get("skill_ids", [])) for q in questions for r in q.get("rubrics", [])
+    ]
+    avg_skills_per_question = (
+        sum(question_skill_counts) / len(question_skill_counts)
+        if question_skill_counts
+        else 0.0
+    )
+    avg_skills_per_rubric = (
+        sum(rubric_skill_counts) / len(rubric_skill_counts)
+        if rubric_skill_counts
+        else 0.0
+    )
+    avg_time_steps_per_student = (
+        num_time_steps / num_students if num_students > 0 else 0.0
+    )
+    avg_questions_per_timestep = (
+        num_questions / num_time_steps if num_time_steps > 0 else 0.0
+    )
+
+    print("\n=== Conversion Summary ===")
+    print(f"Skills:              {num_skills}")
+    print(f"Questions:           {len(questions)}")
+    print(f"Rubrics:             {total_rubrics}")
+    print(f"Avg skills/question: {avg_skills_per_question:.3f}")
+    print(f"Avg skills/rubric:   {avg_skills_per_rubric:.3f}")
+    print(f"Students:            {num_students}")
+    print(f"Time steps:          {num_time_steps}")
+    print(f"Avg timesteps/student: {avg_time_steps_per_student:.3f}")
+    print(f"Avg questions/timestep: {avg_questions_per_timestep:.3f}")
+    print(f"Grouping mode:       {args.grouping_time}")
+    print(f"Unmapped questions:  {unmapped_questions}")
+    print(f"Skipped interactions:{skipped_interactions}")
+    print(f"Output directory:    {output_dir}")
+
+
+if __name__ == "__main__":
+    main()

Code/qwen3next80bvllm_instruct.py

@@ -0,0 +1,35 @@
+"""
+Knowledge Tracing inference with Qwen3-Next-80B-A3B-Instruct model.
+
+This is the standard instruction-following model (no thinking blocks).
+Recommended sampling: temperature=0.7, top_p=0.8, top_k=20, min_p=0
+
+Usage:
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python qwen3next80bvllm_instruct.py \
+        --data-dir foundationalktdataset/ \
+        --num-gpus 4 \
+        --batch-size 10 \
+        --cache-dir /data1/ \
+        --num-students 500 \
+        --bin-size 50 \
+        --min-history 50
+"""
+
+from kt_inference_base import run_inference
+
+MODEL_CONFIG = {
+    "model_id": "Qwen/Qwen3-Next-80B-A3B-Instruct",
+    "gen_configs": {
+        "temperature": 0.7,
+        "top_p": 0.8,
+        "top_k": 20,
+        "min_p": 0.0,
+        "max_tokens": 32768,
+        "repetition_penalty": 1.0,
+    },
+    "output_prefix": "qwen3next80binstruct",
+    "system_prompt_prefix": "",  # No prefix - standard instruct model
+}
+
+if __name__ == "__main__":
+    run_inference(MODEL_CONFIG)

Code/qwen3next80bvllm_thinking.py

@@ -0,0 +1,35 @@
+"""
+Knowledge Tracing inference with Qwen3-Next-80B-A3B-Thinking model.
+
+This model has native thinking mode - it automatically generates <think>...</think> blocks.
+Recommended sampling: temperature=0.6, top_p=0.95, top_k=20, min_p=0
+
+Usage:
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python qwen3next80bvllm_thinking.py \
+        --data-dir foundationalktdataset/ \
+        --num-gpus 4 \
+        --batch-size 10 \
+        --cache-dir /data1/ \
+        --num-students 500 \
+        --bin-size 50 \
+        --min-history 50
+"""
+
+from kt_inference_base import run_inference
+
+MODEL_CONFIG = {
+    "model_id": "Qwen/Qwen3-Next-80B-A3B-Thinking",
+    "gen_configs": {
+        "temperature": 0.6,
+        "top_p": 0.95,
+        "top_k": 20,
+        "min_p": 0.0,
+        "max_tokens": 32768,
+        "repetition_penalty": 1.0,
+    },
+    "output_prefix": "qwen3next80bthinking",
+    "system_prompt_prefix": "",  # No prefix - model has native thinking
+}
+
+if __name__ == "__main__":
+    run_inference(MODEL_CONFIG)

Code/scripts.sh

@@ -0,0 +1,24 @@
+# !/bin/bash
+
+# Student Time Gap Distribution
+python plot_timegap_distribution.py \
+    --bin-time 5 \
+    --plot-upper-limit-minutes 240
+
+# Student Attempt Distribution
+python plot_student_attempt_distribution.py \
+    --bin-time 1440   
+
+python plot_student_attempt_distribution.py \
+    --bin-time 10800
+
+python plot_student_attempt_distribution.py \
+    --bin-time 43200
+
+# Total Time Distribution
+python plot_totaltime_distribution.py \
+    --bin-time 10800
+
+# Preprocess 
+python process_to_single_file.py \
+    --grouping-time 10800

Data/Interactions.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:671e97d320d0cf9b7e2bd75830d531cfbd95d307a1a9a590531934ad0d3d8ba4
+size 245145636

Data/Math_Standards1.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d28ded26c7394f55525550e32bb96786da2e9a3276ccca8873e80ebcdebab11
+size 1242082

Data/Skill_Set.csv

@@ -0,0 +1,165 @@
+index,skill_code,full_description
+1,2.MD.B.5,"Use addition and subtraction within 100 to solve word problems involving lengths that are given in the same units, e.g., by using drawings (such as drawings of rulers) and equations with a symbol for the unknown number to represent the problem."
+2,3.MD.B.3,"Draw a scaled picture graph and a scaled bar graph to represent a data set with several categories. Solve one- and two-step ""how many more"" and ""how many less"" problems using information presented in scaled bar graphs. For example, draw a bar graph in which each square in the bar graph might represent 5 pets."
+3,3.MD.C.6,"Measure areas by counting unit squares (square cm, square m, square in, square ft, and improvised units)."
+4,3.MD.C.7a,"Find the area of a rectangle with whole-number side lengths by tiling it, and show that the area is the same as would be found by multiplying the side lengths."
+5,3.MD.C.7d,"Recognize area as additive. Find areas of rectilinear figures by decomposing them into non-overlapping rectangles and adding the areas of the non-overlapping parts, applying this technique to solve real world problems."
+6,3.MD.D.8,"Solve real world and mathematical problems involving perimeters of polygons, including finding the perimeter given the side lengths, finding an unknown side length, and exhibiting rectangles with the same perimeter and different areas or with the same area and different perimeters."
+7,3.NF.A.2a,Represent a fraction 1/b on a number line diagram by defining the interval from 0 to 1 as the whole and partitioning it into b equal parts. Recognize that each part has size 1/b and that the endpoint of the part based at 0 locates the number 1/b on the number line.
+8,3.NF.A.2b,Represent a fraction a/b on a number line diagram by marking off a lengths 1/b from 0. Recognize that the resulting interval has size a/b and that its endpoint locates the number a/b on the number line.
+9,3.NF.A.3b,"Recognize and generate simple equivalent fractions, e.g., 1/2 = 2/4, 4/6 = 2/3). Explain why the fractions are equivalent, e.g., by using a visual fraction model."
+10,3.NF.A.3d,"Compare two fractions with the same numerator or the same denominator by reasoning about their size. Recognize that comparisons are valid only when the two fractions refer to the same whole. Record the results of comparisons with the symbols >, =, or <, and justify the conclusions, e.g., by using a visual fraction model."
+11,3.OA.A.1,"Interpret products of whole numbers, e.g., interpret 5 × 7 as the total number of objects in 5 groups of 7 objects each. For example, describe a context in which a total number of objects can be expressed as 5 × 7."
+12,3.OA.A.4,"Determine the unknown whole number in a multiplication or division equation relating three whole numbers. For example, determine the unknown number that makes the equation true in each of the equations 8 × ? = 48, 5 = _ ÷ 3, 6 × 6 = ?."
+13,3.OA.B.5,Apply properties of operations as strategies to multiply and divide.
+14,4.G.A.1,"Draw points, lines, line segments, rays, angles (right, acute, obtuse), and perpendicular and parallel lines. Identify these in two-dimensional figures."
+15,4.G.A.2,"Classify two-dimensional figures based on the presence or absence of parallel or perpendicular lines, or the presence or absence of angles of a specified size. Recognize right triangles as a category, and identify right triangles."
+16,4.MD.A.1,"Know relative sizes of measurement units within one system of units including km, m, cm; kg, g; lb, oz.; l, ml; hr, min, sec. Within a single system of measurement, express measurements in a larger unit in terms of a smaller unit. Record measurement equivalents in a two column table. For example, know that 1 ft is 12 times as long as 1 in. Express the length of a 4 ft snake as 48 in. Generate a conversion table for feet and inches listing the number pairs (1, 12), (2, 24), (3, 36), …"
+17,4.MD.A.3,"Apply the area and perimeter formulas for rectangles in real world and mathematical problems. For example, find the width of a rectangular room given the area of the flooring and the length, by viewing the area formula as a multiplication equation with an unknown factor."
+18,4.NBT.A.1,"Recognize that in a multi-digit whole number, a digit in one place represents ten times what it represents in the place to its right. For example, recognize that 700 ÷ 70 = 10 by applying concepts of place value and division."
+19,4.NBT.B.6,"Find whole-number quotients and remainders with up to four-digit dividends and one-digit divisors, using strategies based on place value, the properties of operations, and/or the relationship between multiplication and division. Illustrate and explain the calculation by using equations, rectangular arrays, and/or area models."
+20,4.NF.A.1,"Explain why a fraction a/b is equivalent to a fraction (n × a)/(n × b) by using visual fraction models, with attention to how the number and size of the parts differ even though the two fractions themselves are the same size. Use this principle to recognize and generate equivalent fractions."
+21,4.NF.A.2,"Compare two fractions with different numerators and different denominators, e.g., by creating common denominators or numerators, or by comparing to a benchmark fraction such as 1/2. Recognize that comparisons are valid only when the two fractions refer to the same whole. Record the results of comparisons with symbols >, =, or <, and justify the conclusions, e.g., by using a visual fraction model."
+22,4.NF.B.4b,"Understand a multiple of a/b as a multiple of 1/b, and use this understanding to multiply a fraction by a whole number. For example, use a visual fraction model to express 3 × (2/5) as 6 × (1/5), recognizing this product as 6/5. (In general, n × (a/b) = (n × a)/b.)"
+23,4.NF.C.6,"Use decimal notation for fractions with denominators 10 or 100. For example, rewrite 0.62 as 62/100; describe a length as 0.62 meters; locate 0.62 on a number line diagram."
+24,4.OA.A.1,"Interpret a multiplication equation as a comparison, e.g., interpret 35 = 5 × 7 as a statement that 35 is 5 times as many as 7 and 7 times as many as 5. Represent verbal statements of multiplicative comparisons as multiplication equations."
+25,4.OA.B.4,Find all factor pairs for a whole number in the range 1—100. Recognize that a whole number is a multiple of each of its factors. Determine whether a given whole number in the range 1—100 is a multiple of a given one-digit number. Determine whether a given whole number in the range 1—100 is prime or composite.
+26,5.G.A.1,"Use a pair of perpendicular number lines, called axes, to define a coordinate system, with the intersection of the lines (the origin) arranged to coincide with the 0 on each line and a given point in the plane located by using an ordered pair of numbers, called its coordinates. Understand that the first number indicates how far to travel from the origin in the direction of one axis, and the second number indicates how far to travel in the direction of the second axis, with the convention that the names of the two axes and the coordinates correspond (e.g., x-axis and x-coordinate, y-axis and y-coordinate)."
+27,5.G.A.2,"Represent real world and mathematical problems by graphing points in the first quadrant of the coordinate plane, and interpret coordinate values of points in the context of the situation."
+28,5.G.B.4,Classify two-dimensional figures in a hierarchy based on properties.
+29,5.MD.A.1,"Convert among different-sized standard measurement units within a given measurement system (e.g., convert 5 cm to 0.05 m), and use these conversions in solving multi-step, real world problems."
+30,5.MD.B.2,"Make a line plot to display a data set of measurements in fractions of a unit (1/2, 1/4, 1/8). Use operations on fractions for this grade to solve problems involving information presented in line plots. For example, given different measurements of liquid in identical beakers, find the amount of liquid each beaker would contain if the total amount in all the beakers were redistributed equally."
+31,5.MD.C.3b,A solid figure which can be packed without gaps or overlaps using n unit cubes is said to have a volume of n cubic units.
+32,5.MD.C.4,"Measure volumes by counting unit cubes, using cubic cm, cubic in, cubic ft, and improvised units."
+33,5.MD.C.5a,"Find the volume of a right rectangular prism with whole-number side lengths by packing it with unit cubes, and show that the volume is the same as would be found by multiplying the edge lengths, equivalently by multiplying the height by the area of the base. Represent threefold whole-number products as volumes, e.g., to represent the associative property of multiplication."
+34,5.MD.C.5b,Apply the formulas V = l × w × h and V = b × h for rectangular prisms to find volumes of right rectangular prisms with whole-number edge lengths in the context of solving real world and mathematical problems.
+35,5.NBT.A.1,"Recognize that in a multi-digit number, a digit in one place represents 10 times as much as it represents in the place to its right and 1/10 of what it represents in the place to its left."
+36,5.NBT.A.2,"Explain patterns in the number of zeros of the product when multiplying a number by powers of 10, and explain patterns in the placement of the decimal point when a decimal is multiplied or divided by a power of 10. Use whole-number exponents to denote powers of 10."
+37,5.NBT.A.3b,"Compare two decimals to thousandths based on meanings of the digits in each place, using >, =, and < symbols to record the results of comparisons."
+38,5.NBT.B.5,Fluently multiply multi-digit whole numbers using the standard algorithm.
+39,5.NBT.B.6,"Find whole-number quotients of whole numbers with up to four-digit dividends and two-digit divisors, using strategies based on place value, the properties of operations, and/or the relationship between multiplication and division. Illustrate and explain the calculation by using equations, rectangular arrays, and/or area models."
+40,5.NBT.B.7,"Add, subtract, multiply, and divide decimals to hundredths, using concrete models or drawings and strategies based on place value, properties of operations, and/or the relationship between addition and subtraction; relate the strategy to a written method and explain the reasoning used."
+41,5.NF.A.1,"Add and subtract fractions with unlike denominators (including mixed numbers) by replacing given fractions with equivalent fractions in such a way as to produce an equivalent sum or difference of fractions with like denominators. For example, 2/3 + 5/4 = 8/12 + 15/12 = 23/12. (In general, a/b + c/d = (ad + bc)/bd.)"
+42,5.NF.A.2,"Solve word problems involving addition and subtraction of fractions referring to the same whole, including cases of unlike denominators, e.g., by using visual fraction models or equations to represent the problem. Use benchmark fractions and number sense of fractions to estimate mentally and assess the reasonableness of answers. For example, recognize an incorrect result 2/5 + 1/2 = 3/7, by observing that 3/7"
+43,5.NF.B.3,"Interpret a fraction as division of the numerator by the denominator (a/b = a ÷ b). Solve word problems involving division of whole numbers leading to answers in the form of fractions or mixed numbers, e.g., by using visual fraction models or equations to represent the problem. For example, interpret 3/4 as the result of dividing 3 by 4, noting that 3/4 multiplied by 4 equals 3, and that when 3 wholes are shared equally among 4 people each person has a share of size 3/4. If 9 people want to share a 50-pound sack of rice equally by weight, how many pounds of rice should each person get? Between what two whole numbers does your answer lie?"
+44,5.NF.B.4a,"Interpret the product (a/b) × q as a parts of a partition of q into b equal parts; equivalently, as the result of a sequence of operations a × q ÷ b. For example, use a visual fraction model to show (2/3) × 4 = 8/3, and create a story context for this equation. Do the same with (2/3) × (4/5) = 8/15. (In general, (a/b) × (c/d) = ac/bd.)"
+45,5.NF.B.4b,"Find the area of a rectangle with fractional side lengths by tiling it with unit squares of the appropriate unit fraction side lengths, and show that the area is the same as would be found by multiplying the side lengths. Multiply fractional side lengths to find areas of rectangles, and represent fraction products as rectangular areas."
+46,5.NF.B.5a,"Comparing the size of a product to the size of one factor on the basis of the size of the other factor, without performing the indicated multiplication."
+47,5.NF.B.5b,Explaining why multiplying a given number by a fraction greater than 1 results in a product greater than the given number (recognizing multiplication by whole numbers greater than 1 as a familiar case); explaining why multiplying a given number by a fraction less than 1 results in a product smaller than the given number; and relating the principle of fraction equivalence a/b = (n×a)/(n×b) to the effect of multiplying a/b by 1.
+48,5.NF.B.6,"Solve real world problems involving multiplication of fractions and mixed numbers, e.g., by using visual fraction models or equations to represent the problem."
+49,5.NF.B.7a,"Interpret division of a unit fraction by a non-zero whole number, and compute such quotients. For example, create a story context for (1/3) ÷ 4, and use a visual fraction model to show the quotient. Use the relationship between multiplication and division to explain that (1/3) ÷ 4 = 1/12 because (1/12) × 4 = 1/3."
+50,5.NF.B.7b,"Interpret division of a whole number by a unit fraction, and compute such quotients. For example, create a story context for 4 ÷ (1/5), and use a visual fraction model to show the quotient. Use the relationship between multiplication and division to explain that 4 ÷ (1/5) = 20 because 20 × (1/5) = 4."
+51,5.NF.B.7c,"Solve real world problems involving division of unit fractions by non-zero whole numbers and division of whole numbers by unit fractions, e.g., by using visual fraction models and equations to represent the problem. For example, how much chocolate will each person get if 3 people share 1/2 lb of chocolate equally? How many 1/3-cup servings are in 2 cups of raisins?"
+52,5.OA.A.1,"Use parentheses, brackets, or braces in numerical expressions, and evaluate expressions with these symbols."
+53,5.OA.A.2,"Write simple expressions that record calculations with numbers, and interpret numerical expressions without evaluating them. For example, express the calculation ""add 8 and 7, then multiply by 2"" as 2 × (8 + 7). Recognize that 3 × (18932 + 921) is three times as large as 18932 + 921, without having to calculate the indicated sum or product."
+54,6.EE.A.1,Write and evaluate numerical expressions involving whole-number exponents.
+55,6.EE.A.2a,"Write expressions that record operations with numbers and with letters standing for numbers. For example, express the calculation ""Subtract y from 5"" as 5 - y."
+56,6.EE.A.2b,"Identify parts of an expression using mathematical terms (sum, term, product, factor, quotient, coefficient); view one or more parts of an expression as a single entity. For example, describe the expression 2 (8 + 7) as a product of two factors; view (8 + 7) as both a single entity and a sum of two terms."
+57,6.EE.A.2c,"Evaluate expressions at specific values of their variables. Include expressions that arise from formulas used in real-world problems. Perform arithmetic operations, including those involving whole-number exponents, in the conventional order when there are no parentheses to specify a particular order (Order of Operations). For example, use the formulas V = s³ and A = 6 s² to find the volume and surface area of a cube with sides of length s = 1/2."
+58,6.EE.A.3,"Apply the properties of operations to generate equivalent expressions. For example, apply the distributive property to the expression 3 (2 + x) to produce the equivalent expression 6 + 3x; apply the distributive property to the expression 24x + 18y to produce the equivalent expression 6 (4x + 3y); apply properties of operations to y + y + y to produce the equivalent expression 3y."
+59,6.EE.A.4,"Identify when two expressions are equivalent (i.e., when the two expressions name the same number regardless of which value is substituted into them). For example, the expressions y + y + y and 3y are equivalent because they name the same number regardless of which number y stands for."
+60,6.EE.B.5,"Understand solving an equation or inequality as a process of answering a question: which values from a specified set, if any, make the equation or inequality true? Use substitution to determine whether a given number in a specified set makes an equation or inequality true."
+61,6.EE.B.6,"Use variables to represent numbers and write expressions when solving a real-world or mathematical problem; understand that a variable can represent an unknown number, or, depending on the purpose at hand, any number in a specified set."
+62,6.EE.B.7,"Solve real-world and mathematical problems by writing and solving equations of the form x + p = q and px = q for cases in which p, q and x are all nonnegative rational numbers."
+63,6.EE.B.8,Write an inequality of the form x > c or x c or x < c have infinitely many solutions; represent solutions of such inequalities on number line diagrams.
+64,6.EE.C.9,"Use variables to represent two quantities in a real-world problem that change in relationship to one another; write an equation to express one quantity, thought of as the dependent variable, in terms of the other quantity, thought of as the independent variable. Analyze the relationship between the dependent and independent variables using graphs and tables, and relate these to the equation. For example, in a problem involving motion at constant speed, list and graph ordered pairs of distances and times, and write the equation d = 65t to represent the relationship between distance and time."
+65,6.G.A.1,"Find the area of right triangles, other triangles, special quadrilaterals, and polygons by composing into rectangles or decomposing into triangles and other shapes; apply these techniques in the context of solving real-world and mathematical problems."
+66,6.G.A.2,"Find the volume of a right rectangular prism with fractional edge lengths by packing it with unit cubes of the appropriate unit fraction edge lengths, and show that the volume is the same as would be found by multiplying the edge lengths of the prism. Apply the formulas V = l w h and V = b h to find volumes of right rectangular prisms with fractional edge lengths in the context of solving real-world and mathematical problems."
+67,6.G.A.3,Draw polygons in the coordinate plane given coordinates for the vertices; use coordinates to find the length of a side joining points with the same first coordinate or the same second coordinate. Apply these techniques in the context of solving real-world and mathematical problems.
+68,6.G.A.4,"Represent three-dimensional figures using nets made up of rectangles and triangles, and use the nets to find the surface area of these figures. Apply these techniques in the context of solving real-world and mathematical problems."
+69,6.NS.A.1,"Interpret and compute quotients of fractions, and solve word problems involving division of fractions by fractions, e.g., by using visual fraction models and equations to represent the problem. For example, create a story context for (2/3) ÷ (3/4) and use a visual fraction model to show the quotient; use the relationship between multiplication and division to explain that (2/3) ÷ (3/4) = 8/9 because 3/4 of 8/9 is 2/3. (In general, (a/b) ÷ (c/d) = ad/bc.) How much chocolate will each person get if 3 people share 1/2 lb of chocolate equally? How many 3/4-cup servings are in 2/3 of a cup of yogurt? How wide is a rectangular strip of land with length 3/4 mi and area 1/2 square mi?"
+70,6.NS.B.2,Fluently divide multi-digit numbers using the standard algorithm.
+71,6.NS.B.3,"Fluently add, subtract, multiply, and divide multi-digit decimals using the standard algorithm for each operation."
+72,6.NS.B.4,"Find the greatest common factor of two whole numbers less than or equal to 100 and the least common multiple of two whole numbers less than or equal to 12. Use the distributive property to express a sum of two whole numbers 1—100 with a common factor as a multiple of a sum of two whole numbers with no common factor. For example, express 36 + 8 as 4 (9 + 2)."
+73,6.NS.C.5,"Understand that positive and negative numbers are used together to describe quantities having opposite directions or values (e.g., temperature above/below zero, elevation above/below sea level, credits/debits, positive/negative electric charge); use positive and negative numbers to represent quantities in real-world contexts, explaining the meaning of 0 in each situation."
+74,6.NS.C.6a,"Recognize opposite signs of numbers as indicating locations on opposite sides of 0 on the number line; recognize that the opposite of the opposite of a number is the number itself, e.g., -(-3) = 3, and that 0 is its own opposite."
+75,6.NS.C.6c,Find and position integers and other rational numbers on a horizontal or vertical number line diagram; find and position pairs of integers and other rational numbers on a coordinate plane.
+76,6.NS.C.7a,"Interpret statements of inequality as statements about the relative position of two numbers on a number line diagram. For example, interpret -3 > -7 as a statement that -3 is located to the right of -7 on a number line oriented from left to right."
+77,6.NS.C.7b,"Write, interpret, and explain statements of order for rational numbers in real-world contexts. For example, write -3 °C > -7 °C to express the fact that -3 °C is warmer than -7 °C."
+78,6.NS.C.7c,"Understand the absolute value of a rational number as its distance from 0 on the number line; interpret absolute value as magnitude for a positive or negative quantity in a real-world situation. For example, for an account balance of -30 dollars, write |-30| = 30 to describe the size of the debt in dollars."
+79,6.NS.C.7d,"Distinguish comparisons of absolute value from statements about order. For example, recognize that an account balance less than -30 dollars represents a debt greater than 30 dollars."
+80,6.NS.C.8,Solve real-world and mathematical problems by graphing points in all four quadrants of the coordinate plane. Include use of coordinates and absolute value to find distances between points with the same first coordinate or the same second coordinate.
+81,6.RP.A.1,"Understand the concept of a ratio and use ratio language to describe a ratio relationship between two quantities. For example, ""The ratio of wings to beaks in the bird house at the zoo was 2:1, because for every 2 wings there was 1 beak."" ""For every vote candidate A received, candidate C received nearly three votes."""
+82,6.RP.A.2,"Understand the concept of a unit rate a/b associated with a ratio a:b with b ≠ 0, and use rate language in the context of a ratio relationship."
+83,6.RP.A.3a,"Make tables of equivalent ratios relating quantities with whole number measurements, find missing values in the tables, and plot the pairs of values on the coordinate plane. Use tables to compare ratios."
+84,6.RP.A.3b,"Solve unit rate problems including those involving unit pricing and constant speed. For example, if it took 7 hours to mow 4 lawns, then at that rate, how many lawns could be mowed in 35 hours? At what rate were lawns being mowed?"
+85,6.RP.A.3c,"Find a percent of a quantity as a rate per 100 (e.g., 30% of a quantity means 30/100 times the quantity); solve problems involving finding the whole, given a part and the percent."
+86,6.RP.A.3d,Use ratio reasoning to convert measurement units; manipulate and transform units appropriately when multiplying or dividing quantities.
+87,6.SP.A.1,"Recognize a statistical question as one that anticipates variability in the data related to the question and accounts for it in the answers. For example, ""How old am I?"" is not a statistical question, but ""How old are the students in my school?"" is a statistical question because one anticipates variability in students' ages."
+88,6.SP.A.2,"Understand that a set of data collected to answer a statistical question has a distribution which can be described by its center, spread, and overall shape."
+89,6.SP.A.3,"Recognize that a measure of center for a numerical data set summarizes all of its values with a single number, while a measure of variation describes how its values vary with a single number."
+90,6.SP.B.4,"Display numerical data in plots on a number line, including dot plots, histograms, and box plots."
+91,6.SP.B.5a,Reporting the number of observations.
+92,6.SP.B.5b,"Describing the nature of the attribute under investigation, including how it was measured and its units of measurement."
+93,6.SP.B.5c,"Giving quantitative measures of center (median and/or mean) and variability (interquartile range and/or mean absolute deviation), as well as describing any overall pattern and any striking deviations from the overall pattern with reference to the context in which the data were gathered."
+94,6.SP.B.5d,Relating the choice of measures of center and variability to the shape of the data distribution and the context in which the data were gathered.
+95,7.EE.A.1,"Apply properties of operations as strategies to add, subtract, factor, and expand linear expressions with rational coefficients."
+96,7.EE.A.2,"Understand that rewriting an expression in different forms in a problem context can shed light on the problem and how the quantities in it are related. For example, a + 0.05a = 1.05a means that ""increase by 5%"" is the same as ""multiply by 1.05."""
+97,7.EE.B.3,"Solve multi-step real-life and mathematical problems posed with positive and negative rational numbers in any form (whole numbers, fractions, and decimals), using tools strategically. Apply properties of operations to calculate with numbers in any form; convert between forms as appropriate; and assess the reasonableness of answers using mental computation and estimation strategies. For example: If a woman making $25 an hour gets a 10% raise, she will make an additional 1/10 of her salary an hour, or $2.50, for a new salary of $27.50. If you want to place a towel bar 9 3/4 inches long in the center of a door that is 27 1/2 inches wide, you will need to place the bar about 9 inches from each edge; this estimate can be used as a check on the exact computation."
+98,7.EE.B.4a,"Solve word problems leading to equations of the form px + q = r and p(x + q) = r, where p, q, and r are specific rational numbers. Solve equations of these forms fluently. Compare an algebraic solution to an arithmetic solution, identifying the sequence of the operations used in each approach. For example, the perimeter of a rectangle is 54 cm. Its length is 6 cm. What is its width?"
+99,7.EE.B.4b,"Solve word problems leading to inequalities of the form px + q > r or px + q For example: As a salesperson, you are paid $50 per week plus $3 per sale. This week you want your pay to be at least $100. Write an inequality for the number of sales you need to make, and describe the solutions."
+100,7.G.A.1,"Solve problems involving scale drawings of geometric figures, including computing actual lengths and areas from a scale drawing and reproducing a scale drawing at a different scale."
+101,7.G.A.2,"Draw (freehand, with ruler and protractor, and with technology) geometric shapes with given conditions. Focus on constructing triangles from three measures of angles or sides, noticing when the conditions determine a unique triangle, more than one triangle, or no triangle."
+102,7.G.A.3,"Describe the two-dimensional figures that result from slicing three-dimensional figures, as in plane sections of right rectangular prisms and right rectangular pyramids."
+103,7.G.B.4,Know the formulas for the area and circumference of a circle and use them to solve problems; give an informal derivation of the relationship between the circumference and area of a circle.
+104,7.G.B.5,"Use facts about supplementary, complementary, vertical, and adjacent angles in a multi-step problem to write and solve simple equations for an unknown angle in a figure."
+105,7.G.B.6,"Solve real-world and mathematical problems involving area, volume and surface area of two- and three-dimensional objects composed of triangles, quadrilaterals, polygons, cubes, and right prisms."
+106,7.NS.A.1a,"Describe situations in which opposite quantities combine to make 0. For example, a hydrogen atom has 0 charge because its two constituents are oppositely charged."
+107,7.NS.A.1b,"Understand p + q as the number located a distance |q| from p, in the positive or negative direction depending on whether q is positive or negative. Show that a number and its opposite have a sum of 0 (are additive inverses). Interpret sums of rational numbers by describing real-world contexts."
+108,7.NS.A.1c,"Understand subtraction of rational numbers as adding the additive inverse, p - q = p + (-q). Show that the distance between two rational numbers on the number line is the absolute value of their difference, and apply this principle in real-world contexts."
+109,7.NS.A.1d,Apply properties of operations as strategies to add and subtract rational numbers.
+110,7.NS.A.2a,"Understand that multiplication is extended from fractions to rational numbers by requiring that operations continue to satisfy the properties of operations, particularly the distributive property, leading to products such as (-1)(-1) = 1 and the rules for multiplying signed numbers. Interpret products of rational numbers by describing real-world contexts."
+111,7.NS.A.2b,"Understand that integers can be divided, provided that the divisor is not zero, and every quotient of integers (with non-zero divisor) is a rational number. If p and q are integers, then -(p/q) = (-p)/q = p/(-q). Interpret quotients of rational numbers by describing real-world contexts."
+112,7.NS.A.2c,Apply properties of operations as strategies to multiply and divide rational numbers.
+113,7.NS.A.2d,Convert a rational number to a decimal using long division; know that the decimal form of a rational number terminates in 0s or eventually repeats.
+114,7.NS.A.3,Solve real-world and mathematical problems involving the four operations with rational numbers.
+115,7.RP.A.1,"Compute unit rates associated with ratios of fractions, including ratios of lengths, areas and other quantities measured in like or different units. For example, if a person walks 1/2 mile in each 1/4 hour, compute the unit rate as the complex fraction 1/2/1/4 miles per hour, equivalently 2 miles per hour."
+116,7.RP.A.2a,"Decide whether two quantities are in a proportional relationship, e.g., by testing for equivalent ratios in a table or graphing on a coordinate plane and observing whether the graph is a straight line through the origin."
+117,7.RP.A.2b,"Identify the constant of proportionality (unit rate) in tables, graphs, equations, diagrams, and verbal descriptions of proportional relationships."
+118,7.RP.A.2c,"Represent proportional relationships by equations. For example, if total cost t is proportional to the number n of items purchased at a constant price p, the relationship between the total cost and the number of items can be expressed as t = pn."
+119,7.RP.A.2d,"Explain what a point (x, y) on the graph of a proportional relationship means in terms of the situation, with special attention to the points (0, 0) and (1, r) where r is the unit rate."
+120,7.RP.A.3,Use proportional relationships to solve multistep ratio and percent problems.
+121,7.SP.A.1,Understand that statistics can be used to gain information about a population by examining a sample of the population; generalizations about a population from a sample are valid only if the sample is representative of that population. Understand that random sampling tends to produce representative samples and support valid inferences.
+122,7.SP.A.2,"Use data from a random sample to draw inferences about a population with an unknown characteristic of interest. Generate multiple samples (or simulated samples) of the same size to gauge the variation in estimates or predictions. For example, estimate the mean word length in a book by randomly sampling words from the book; predict the winner of a school election based on randomly sampled survey data. Gauge how far off the estimate or prediction might be."
+123,7.SP.B.3,"Informally assess the degree of visual overlap of two numerical data distributions with similar variabilities, measuring the difference between the centers by expressing it as a multiple of a measure of variability. For example, the mean height of players on the basketball team is 10 cm greater than the mean height of players on the soccer team, about twice the variability (mean absolute deviation) on either team; on a dot plot, the separation between the two distributions of heights is noticeable."
+124,7.SP.B.4,"Use measures of center and measures of variability for numerical data from random samples to draw informal comparative inferences about two populations. For example, decide whether the words in a chapter of a seventh-grade science book are generally longer than the words in a chapter of a fourth-grade science book."
+125,7.SP.C.5,"Understand that the probability of a chance event is a number between 0 and 1 that expresses the likelihood of the event occurring. Larger numbers indicate greater likelihood. A probability near 0 indicates an unlikely event, a probability around 1/2 indicates an event that is neither unlikely nor likely, and a probability near 1 indicates a likely event."
+126,7.SP.C.6,"Approximate the probability of a chance event by collecting data on the chance process that produces it and observing its long-run relative frequency, and predict the approximate relative frequency given the probability. For example, when rolling a number cube 600 times, predict that a 3 or 6 would be rolled roughly 200 times, but probably not exactly 200 times."
+127,7.SP.C.7a,"Develop a uniform probability model by assigning equal probability to all outcomes, and use the model to determine probabilities of events. For example, if a student is selected at random from a class, find the probability that Jane will be selected and the probability that a girl will be selected."
+128,7.SP.C.7b,"Develop a probability model (which may not be uniform) by observing frequencies in data generated from a chance process. For example, find the approximate probability that a spinning penny will land heads up or that a tossed paper cup will land open-end down. Do the outcomes for the spinning penny appear to be equally likely based on the observed frequencies?"
+129,7.SP.C.8a,"Understand that, just as with simple events, the probability of a compound event is the fraction of outcomes in the sample space for which the compound event occurs."
+130,7.SP.C.8b,"Represent sample spaces for compound events using methods such as organized lists, tables and tree diagrams. For an event described in everyday language (e.g., ""rolling double sixes""), identify the outcomes in the sample space which compose the event."
+131,7.SP.C.8c,"Design and use a simulation to generate frequencies for compound events. For example, use random digits as a simulation tool to approximate the answer to the question: If 40% of donors have type A blood, what is the probability that it will take at least 4 donors to find one with type A blood?"
+132,8.EE.A.1,"Know and apply the properties of integer exponents to generate equivalent numerical expressions. For example, 3² × 3-5 = 3-3 = 1/3³ = 1/27."
+133,8.EE.A.2,"Use square root and cube root symbols to represent solutions to equations of the form x² = p and x³ = p, where p is a positive rational number. Evaluate square roots of small perfect squares and cube roots of small perfect cubes. Know that √2 is irrational."
+134,8.EE.A.3,"Use numbers expressed in the form of a single digit times an integer power of 10 to estimate very large or very small quantities, and to express how many times as much one is than the other. For example, estimate the population of the United States as 3 × 108 and the population of the world as 7 × 109, and determine that the world population is more than 20 times larger."
+135,8.EE.A.4,"Perform operations with numbers expressed in scientific notation, including problems where both decimal and scientific notation are used. Use scientific notation and choose units of appropriate size for measurements of very large or very small quantities (e.g., use millimeters per year for seafloor spreading). Interpret scientific notation that has been generated by technology."
+136,8.EE.B.5,"Graph proportional relationships, interpreting the unit rate as the slope of the graph. Compare two different proportional relationships represented in different ways. For example, compare a distance-time graph to a distance-time equation to determine which of two moving objects has greater speed."
+137,8.EE.B.6,Use similar triangles to explain why the slope m is the same between any two distinct points on a non-vertical line in the coordinate plane; derive the equation y = mx for a line through the origin and the equation y = mx + b for a line intercepting the vertical axis at b.
+138,8.EE.C.7a,"Give examples of linear equations in one variable with one solution, infinitely many solutions, or no solutions. Show which of these possibilities is the case by successively transforming the given equation into simpler forms, until an equivalent equation of the form x = a, a = a, or a = b results (where a and b are different numbers)."
+139,8.EE.C.7b,"Solve linear equations with rational number coefficients, including equations whose solutions require expanding expressions using the distributive property and collecting like terms."
+140,8.EE.C.8a,"Understand that solutions to a system of two linear equations in two variables correspond to points of intersection of their graphs, because points of intersection satisfy both equations simultaneously."
+141,8.EE.C.8b,"Solve systems of two linear equations in two variables algebraically, and estimate solutions by graphing the equations. Solve simple cases by inspection. For example, 3x + 2y = 5 and 3x + 2y = 6 have no solution because 3x + 2y cannot simultaneously be 5 and 6."
+142,8.EE.C.8c,"Solve real-world and mathematical problems leading to two linear equations in two variables. For example, given coordinates for two pairs of points, determine whether the line through the first pair of points intersects the line through the second pair."
+143,8.F.A.1,Understand that a function is a rule that assigns to each input exactly one output. The graph of a function is the set of ordered pairs consisting of an input and the corresponding output.
+144,8.F.A.2,"Compare properties of two functions each represented in a different way (algebraically, graphically, numerically in tables, or by verbal descriptions). For example, given a linear function represented by a table of values and a linear function represented by an algebraic expression, determine which function has the greater rate of change."
+145,8.F.A.3,"Interpret the equation y = mx + b as defining a linear function, whose graph is a straight line; give examples of functions that are not linear. For example, the function A = s² giving the area of a square as a function of its side length is not linear because its graph contains the points (1,1), (2,4) and (3,9), which are not on a straight line."
+146,8.F.B.4,"Construct a function to model a linear relationship between two quantities. Determine the rate of change and initial value of the function from a description of a relationship or from two (x, y) values, including reading these from a table or from a graph. Interpret the rate of change and initial value of a linear function in terms of the situation it models, and in terms of its graph or a table of values."
+147,8.F.B.5,"Describe qualitatively the functional relationship between two quantities by analyzing a graph (e.g., where the function is increasing or decreasing, linear or nonlinear). Sketch a graph that exhibits the qualitative features of a function that has been described verbally."
+148,8.G.A.1a,"Lines are taken to lines, and line segments to line segments of the same length."
+149,8.G.A.1b,Angles are taken to angles of the same measure.
+150,8.G.A.1c,Parallel lines are taken to parallel lines.
+151,8.G.A.2,"Understand that a two-dimensional figure is congruent to another if the second can be obtained from the first by a sequence of rotations, reflections, and translations; given two congruent figures, describe a sequence that exhibits the congruence between them."
+152,8.G.A.3,"Describe the effect of dilations, translations, rotations, and reflections on two-dimensional figures using coordinates."
+153,8.G.A.4,"Understand that a two-dimensional figure is similar to another if the second can be obtained from the first by a sequence of rotations, reflections, translations, and dilations; given two similar two-dimensional figures, describe a sequence that exhibits the similarity between them."
+154,8.G.A.5,"Use informal arguments to establish facts about the angle sum and exterior angle of triangles, about the angles created when parallel lines are cut by a transversal, and the angle-angle criterion for similarity of triangles. For example, arrange three copies of the same triangle so that the sum of the three angles appears to form a line, and give an argument in terms of transversals why this is so."
+155,8.G.B.6,Explain a proof of the Pythagorean Theorem and its converse.
+156,8.G.B.7,Apply the Pythagorean Theorem to determine unknown side lengths in right triangles in real-world and mathematical problems in two and three dimensions.
+157,8.G.B.8,Apply the Pythagorean Theorem to find the distance between two points in a coordinate system.
+158,8.G.C.9,"Know the formulas for the volumes of cones, cylinders, and spheres and use them to solve real-world and mathematical problems."
+159,8.NS.A.1,"Know that numbers that are not rational are called irrational. Understand informally that every number has a decimal expansion; for rational numbers show that the decimal expansion repeats eventually, and convert a decimal expansion which repeats eventually into a rational number."
+160,8.NS.A.2,"Use rational approximations of irrational numbers to compare the size of irrational numbers, locate them approximately on a number line diagram, and estimate the value of expressions (e.g., π²). For example, by truncating the decimal expansion of √2, show that √2 is between 1 and 2, then between 1.4 and 1.5, and explain how to continue on to get better approximations."
+161,8.SP.A.1,"Construct and interpret scatter plots for bivariate measurement data to investigate patterns of association between two quantities. Describe patterns such as clustering, outliers, positive or negative association, linear association, and nonlinear association."
+162,8.SP.A.2,"Know that straight lines are widely used to model relationships between two quantitative variables. For scatter plots that suggest a linear association, informally fit a straight line, and informally assess the model fit by judging the closeness of the data points to the line."
+163,8.SP.A.3,"Use the equation of a linear model to solve problems in the context of bivariate measurement data, interpreting the slope and intercept. For example, in a linear model for a biology experiment, interpret a slope of 1.5 cm/hr as meaning that an additional hour of sunlight each day is associated with an additional 1.5 cm in mature plant height."
+164,8.SP.A.4,"Understand that patterns of association can also be seen in bivariate categorical data by displaying frequencies and relative frequencies in a two-way table. Construct and interpret a two-way table summarizing data on two categorical variables collected from the same subjects. Use relative frequencies calculated for rows or columns to describe possible association between the two variables. For example, collect data from students in your class on whether or not they have a curfew on school nights and whether or not they have assigned chores at home. Is there evidence that those who have a curfew also tend to have chores?"

README.md

@@ -0,0 +1,246 @@
+---
+license: cc-by-nc-4.0
+
+extra_gated_prompt: "You agree to our [Responsible Use Guidelines](https://www.etrialstestbed.org/mathnet57963-guidelines)."
+    
+extra_gated_fields:
+  First and Last Name: text
+  Affiliation(university, company, etc): text
+  Country: country
+  Why are you asking to use this dataset?: text
+  How are you going to use this dataset?: text
+  How will you store and secure this data?: text
+  Do you have a university-affiliated email we could use to verify your request? If so, please enter it, if not, please explain why: text
+  
+  I agree to use this dataset for non-commercial use ONLY: checkbox
+  While we think it's impossible for you to identify a student from these answers, you need to agree to not try to do so, and you also need to inform us if you find any PII in any of the images with the filenames: checkbox
+  Check box - I agree that this data will be stored on secured institutional systems, will not be shared with unauthorized parties and will deleted or returned to ASSISTments when my research is complete: checkbox
+
+configs:
+  - config_name: Foundational ASSIST Dataset
+    data_files: Data/Problems.csv
+  - config_name: Interactions
+    data_files: Data/Interactions.csv
+  - config_name: Skills
+    data_files: Data/Skills.csv
+    
+---
+
+**IMPORTANT UPDATE ON 3/19:** Due to an issue with git LFS 700k rows in interactions.csv were missing. Please redownload the dataset to use these rows.
+
+# Overview of Foundational ASSIST
+Foundational ASSIST is a dataset containing all natural text of problems and student answers as recorded by ASSISTments. The problems are from  from Illustrative Mathematics 6th - 8th grade math curriculum, a common core aligned curriculum popular in the United States. 
+
+The data is in the "Data" folder. The code used to generate results in the original paper by Worden et al. is in the Code folder, and the results (in case you do not wish to reinference) are in the "Results" folder.
+
+The dataset is comprised of three files: 
+1. **Interactions**, which contains students attempts of problems, 
+2. **Problems**, which includes information relevant to problems, and 
+3. **Skills**, which links Problems to skills. 
+The dataset was curated to include 5,000 unique students who have each completed between 211-421 problems in ASSISTments. The dataset includes 1.7 million instances of students solving problems, complete with the answer text, problem text, distractor text, and more.
+
+# Interactions File
+Interactions consists of 1,722,169 unique instances of students solving problems. The information provided includes a) problem_id, linking to Problems b) hint_count, the number of hints the student requested c) answer_text, the exact text of their first answer d) saw_answer, a boolean indicating whether the student requested to see the correct answer e) discrete_score, 0 the students score f) end_time, the time at which the student put in the correct answer to the problem g) user_xid, a unique identifier for each student.
+
+Note that ASSISTments provides a discrete_score of 1 only if the student gets the problem correct on their first attempt, without requesting any support. If the student requests a hint, requests the answer, or has multiple tries they receive a 0. Accordingly, a student's answer can be the correct answer, but they can receive a 0 if the student requests a hint or sees the answer before entering the answer. This is shown in “table 7 cognitive accuracy when answers are incorrect” in our paper.
+
+# Problems File
+This file consists of information about 3,395 unique problems. The columns include 
+1. Problem Set Id, which links problems that follow one another 
+2. Problem Part, which indicates where in the Problem Set the problem occurs 
+3. Problem Type, describing the type of problem 
+4. Answer Type, describing the type of answer (see below table or more information) 
+5. Problem Body, the problem text with HTML or markup illustrating exactly what the student saw (code to convert to natural language is available on the github) 
+6. Fill-in Options 
+7. Fill-in Answers 
+8. Multiple Choice Options 
+9. Multiple Choice Answers 
+10. problem_id
+
+Problem Set example: PSB6N4 consists of three problems. The first is problem_id 151389 (as it has ‘Problem Part’ = 1, the second is problem_id 151533, and the third/last is 151647.
+
+
+<table>
+  <tr>
+   <td>Answer Type
+   </td>
+   <td>Description
+   </td>
+   <td>Fill-in Options
+   </td>
+   <td>Fill-in Answers
+   </td>
+   <td>Multiple Choice Options
+   </td>
+   <td>Multiple Choice Answers
+   </td>
+  </tr>
+  <tr>
+   <td>Numeric
+   </td>
+   <td>The student must type in the correct number
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Drop Down
+   </td>
+   <td>The student must select the correct option from a drop-down menu. These are similar to multiple choice
+   </td>
+   <td>All the drop down options, separated by “&lt;/p>,”
+   </td>
+   <td>The correct dropdown option.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Algebraic Expression
+   </td>
+   <td>The student must type in the correct, short, algebraic expression, or a similar equivalent expression. E.g. if the answer is a^2+b^2 then b^2+a^2 would also be correct.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Ordering
+   </td>
+   <td>The student must order some values in some order. Note the initial order of how these are presented to students is randomized.
+   </td>
+   <td>The correct order of objects, separated by “,”. 
+   </td>
+   <td>The correct order of objects, separated by “,”.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Exact Match
+   </td>
+   <td>The student must type in exactly the correct answer. This could be a number, expression, point, list, etc.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”. Note that some answers, e.g. lists, require the whole text (1,2,3) and there is only a single answer.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”. Note that some answers, e.g. lists, require the whole text (1,2,3) and there is only a single answer.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Exact Fraction
+   </td>
+   <td>The student must type in exactly the correct fraction.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Numeric Expression
+   </td>
+   <td>The student must type in a numeric expression. Note that simplification occurs, e.g. if the answer is 11^3, 1331 is also considered correct.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>The correct answer. If there are multiple correct answers they are separated by a “,”.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+  </tr>
+  <tr>
+   <td>Multiple Choice
+   </td>
+   <td>The student must select the correct option.
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+   <td>A list of options, separated by ‘||’.
+   </td>
+   <td>The correct option.
+   </td>
+  </tr>
+  <tr>
+   <td>Check all that apply
+   </td>
+   <td>The student must select all correct option(s).
+   </td>
+   <td>n/a
+   </td>
+   <td>n/a
+   </td>
+   <td>A list of options, separated by ‘||’.
+   </td>
+   <td>The correct option(s), separated by ‘||’.
+   </td>
+  </tr>
+</table>
+
+# Skills File
+The skills file consists of 
+1) problem_id, linking to problems in the Problems file 
+2) skill_id, a unique identifier per skill 
+3) node_code, which identifies the ASSISTments Skill tag Illustrative Math code for the skill and 
+4) node_name, a description of the skill. In total there are 224 unique skills.
+
+# Data Source
+All data across each file are from [ASSISTments](https://new.assistments.org/), where students complete in-class work as well as homework and receive support and feedback from the platform. This work was done in conjunction with [Dr. Heffernan’s lab at WPI](https://www.neilheffernan.net/home). To ensure student privacy, our team attempted to remove all Personal Identifiable Information (PII). However, it is possible students could type PII into fill-in problems, which we aimed to detect and remove, but short of a manual review of 1.7 million interaction logs becomes infeasible. Accordingly, we ask that if people using this dataset come across PII to please contact us at [etrials@assistments.org](etrials@assistments.org) so it can be removed.
+
+# License and Sharing Agreement
+This dataset is licensed under CC-BY-NC-4.0. We require that this dataset is used for research and educational purposes following this 
+[Responsible Use Guidelines](https://www.etrialstestbed.org/mathnet57963-guidelines).
+
+# Citation
+
+If you use the **FoundationalASSIST** dataset in your research, please cite the following paper:
+
+> Worden, E., Heffernan, C., Heffernan, N., & Sonkar, S. (2026). FoundationalASSIST: An Educational Dataset for Foundational Knowledge Tracing and Pedagogical Grounding of LLMs. *arXiv preprint arXiv:2602.00070*.
+
+### BibTeX
+
+```bibtex
+@article{worden2026foundationalassist,
+  title={FoundationalASSIST: An Educational Dataset for Foundational Knowledge Tracing and Pedagogical Grounding of LLMs},
+  author={Worden, Eamon and Heffernan, Cristina and Heffernan, Neil and Sonkar, Shashank},
+  journal={arXiv preprint arXiv:2602.00070},
+  year={2026}
+}
+```
+
+### FAQs
+Q: Where is the code that cleans the problem text?
+A: This repository, in Code/clean_utils.py or cleantext.py, both are similar.
+
+Q: How does discrete_score work?
+A: Discrete score is 1 if the student solved the problem on their first try without requesting a hint (hint_count) or an explanation/seeing the answer (saw_answer).
+Note this is recorded by ASSISTments. There are 433 rows where discrete_score = 1 despite saw_answer = True or hint_count > 0. In these instances, the student correctly solved the problem then requested hints/explanation/the answer anyways.
+
+Q: Does the dataset track multiple attempts? (E.g. the student first incorrectly said 3, then incorrectly answered 6, then correctly answered 9)
+A: No. We recognize it may be valuable to have this data. However, currently, answer_text (in Interactions.csv) is the first answer (right or wrong) the student submitted for the problem. Second/future attempts are not included in this dataset, but stay tuned.

Results/Problems_duplicated_problem_id.csv

@@ -0,0 +1,209 @@
+Problem Set Id,Problem Part,Problem Type,Answer Types,Problem Body,Fill-in Options,Fill-in Answers,Multiple Choice Options,Multiple Choice Answers,problem_id,duplicate_group_id,duplicate_problem_id_count,distinct_problem_body_count
+PSBBP4J,2,Fill-in-the-blank(s),Numeric,"<p>Find the area of the triangle.</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/dd6e2450-6c1c-4383-af11-f5f38d8a554f.jpeg"" alt=""A triangle on a grid."" width=""400"" height=""148""></p>",11,11,,,242640,1,2,1
+PSBBP4J,2,Fill-in-the-blank(s),Numeric,"<p>Find the area of the triangle.</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/dd6e2450-6c1c-4383-af11-f5f38d8a554f.jpeg"" alt=""A triangle on a grid."" width=""400"" height=""148""></p>",11,11,,,242640,1,2,1
+PSBBPYN,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this trapezoid.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/de588b0b-4edc-4a7d-a1c9-ae9534107846.jpeg"" alt=""Trapezoid, bases 8 and 4 units. Height 3 units."" width=""287"" height=""158""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r>square units</p>",18,18,,,242072,2,2,1
+PSBBPYN,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this trapezoid.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/de588b0b-4edc-4a7d-a1c9-ae9534107846.jpeg"" alt=""Trapezoid, bases 8 and 4 units. Height 3 units."" width=""287"" height=""158""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r>square units</p>",18,18,,,242072,2,2,1
+PSBBUFM,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of the shaded region in square units.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/ad6cb685-7371-4c50-b2d5-b0417869595c.jpeg"" width=""278"" height=""277""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",40,40,,,266614,3,2,1
+PSBBUFM,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of the shaded region in square units.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/ad6cb685-7371-4c50-b2d5-b0417869595c.jpeg"" width=""278"" height=""277""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",40,40,,,266614,3,2,1
+PSBCTHE,3,Fill-in-the-blank(s),Numeric,"<p>There are 3 cats in a room and no other creatures. Each cat has 2 ears, 4 paws, and 1 tail.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/89240f58-bda5-4371-9d5b-35881563e526.jpeg"" width=""357"" height=""143""></p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>Complete each statement:</p>
+<p>&nbsp;</p>
+<p>There are <ast-r type=""text"" marker=""1""></ast-r> paws for every tail.<br><br></p>
+<p>There are <ast-r type=""text"" marker=""2""></ast-r> paws for every ear.</p>","2, 4","2, 4",,,437233,4,4,1
+PSBCTHE,3,Fill-in-the-blank(s),Numeric,"<p>There are 3 cats in a room and no other creatures. Each cat has 2 ears, 4 paws, and 1 tail.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/89240f58-bda5-4371-9d5b-35881563e526.jpeg"" width=""357"" height=""143""></p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>Complete each statement:</p>
+<p>&nbsp;</p>
+<p>There are <ast-r type=""text"" marker=""1""></ast-r> paws for every tail.<br><br></p>
+<p>There are <ast-r type=""text"" marker=""2""></ast-r> paws for every ear.</p>","2, 4","2, 4",,,437233,4,4,1
+PSBCTHE,3,Fill-in-the-blank(s),Numeric,"<p>There are 3 cats in a room and no other creatures. Each cat has 2 ears, 4 paws, and 1 tail.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/89240f58-bda5-4371-9d5b-35881563e526.jpeg"" width=""357"" height=""143""></p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>Complete each statement:</p>
+<p>&nbsp;</p>
+<p>There are <ast-r type=""text"" marker=""1""></ast-r> paws for every tail.<br><br></p>
+<p>There are <ast-r type=""text"" marker=""2""></ast-r> paws for every ear.</p>","2, 4","2, 4",,,437233,4,4,1
+PSBCTHE,3,Fill-in-the-blank(s),Numeric,"<p>There are 3 cats in a room and no other creatures. Each cat has 2 ears, 4 paws, and 1 tail.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/89240f58-bda5-4371-9d5b-35881563e526.jpeg"" width=""357"" height=""143""></p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>Complete each statement:</p>
+<p>&nbsp;</p>
+<p>There are <ast-r type=""text"" marker=""1""></ast-r> paws for every tail.<br><br></p>
+<p>There are <ast-r type=""text"" marker=""2""></ast-r> paws for every ear.</p>","4, 2","4, 2",,,437233,4,4,1
+PRABFEFN,1,Fill-in-the-blank(s),Numeric,"<p>A square has a side length of 5 feet. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square feet</p>",25,25,,,89104,5,4,1
+PRABFEFN,1,Fill-in-the-blank(s),Numeric,"<p>A square has a side length of 5 feet. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square feet</p>",25,25,,,89104,5,4,1
+PRABFEFN,1,Fill-in-the-blank(s),Numeric,"<p>A square has a side length of 5 feet. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square feet</p>",25,25,,,89104,5,4,1
+PRABFEFN,1,Fill-in-the-blank(s),Numeric,"<p>A square has a side length of 5 feet. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square feet</p>",25,25,,,89104,5,4,1
+PRABE64P,1,Fill-in-the-blank(s),Numeric,"<p>A square is 3 inches by 3 inches. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square inches</p>",9,9,,,88850,6,4,1
+PRABE64P,1,Fill-in-the-blank(s),Numeric,"<p>A square is 3 inches by 3 inches. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square inches</p>",9,9,,,88850,6,4,1
+PRABE64P,1,Fill-in-the-blank(s),Numeric,"<p>A square is 3 inches by 3 inches. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square inches</p>",9,9,,,88850,6,4,1
+PRABE64P,1,Fill-in-the-blank(s),Numeric,"<p>A square is 3 inches by 3 inches. What is its area?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square inches</p>",9,9,,,88850,6,4,1
+PRABFEFP,1,Fill-in-the-blank(s),Numeric,"<p>The area of a square is 36 square centimeters. What is the length of each side of the square?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> centimeters</p>",6,6,,,89321,7,4,1
+PRABFEFP,1,Fill-in-the-blank(s),Numeric,"<p>The area of a square is 36 square centimeters. What is the length of each side of the square?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> centimeters</p>",6,6,,,89321,7,4,1
+PRABFEFP,1,Fill-in-the-blank(s),Numeric,"<p>The area of a square is 36 square centimeters. What is the length of each side of the square?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> centimeters</p>",6,6,,,89321,7,4,1
+PRABFEFP,1,Fill-in-the-blank(s),Numeric,"<p>The area of a square is 36 square centimeters. What is the length of each side of the square?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> centimeters</p>",6,6,,,89321,7,4,1
+PSBTTU,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this quadrilateral.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/e2e6b7c7-6b81-42ca-b6df-a45cd250d4dd.jpeg"" alt=""A blue quadrilateral in the shape of a kite.&nbsp; Two smaller sides span across 3 squares. Two longer sides span across 5 squares."" width=""303"" height=""238""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",24,24,,,88316,8,4,1
+PSBTTU,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this quadrilateral.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/e2e6b7c7-6b81-42ca-b6df-a45cd250d4dd.jpeg"" alt=""A blue quadrilateral in the shape of a kite.&nbsp; Two smaller sides span across 3 squares. Two longer sides span across 5 squares."" width=""303"" height=""238""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",24,24,,,88316,8,4,1
+PSBTTU,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this quadrilateral.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/e2e6b7c7-6b81-42ca-b6df-a45cd250d4dd.jpeg"" alt=""A blue quadrilateral in the shape of a kite.&nbsp; Two smaller sides span across 3 squares. Two longer sides span across 5 squares."" width=""303"" height=""238""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",24,24,,,88316,8,4,1
+PSBTTU,1,Fill-in-the-blank(s),Numeric,"<p>Find the area of this quadrilateral.</p>
+<p>&nbsp;</p>
+<p><img src=""//resources.assistments.org/fetch/C/e2e6b7c7-6b81-42ca-b6df-a45cd250d4dd.jpeg"" alt=""A blue quadrilateral in the shape of a kite.&nbsp; Two smaller sides span across 3 squares. Two longer sides span across 5 squares."" width=""303"" height=""238""></p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> square units</p>",24,24,,,88316,8,4,1
+PRABE64M,1,Multiple Choice (select all),Check All That Apply,"<p>Here is a diagram that describes the cups of green and white paint in a mixture.</p>
+<p>&nbsp;</p>
+<table style=""height: 46px; width: 439px;"">
+<tbody>
+<tr>
+<td style=""width: 162.599px;"">green paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519919.jpg"" alt=""Four squares labeled &quot;green paint (cups)&quot;"" width=""200"" height=""43""></td>
+</tr>
+<tr>
+<td style=""width: 162.599px;"">white paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519920.jpg"" alt=""Two squares labeled &quot;white paint (cups)&quot;"" width=""200"" height=""50""></td>
+</tr>
+</tbody>
+</table>
+<p>&nbsp;</p>
+<p>Select&nbsp;<strong>all</strong> the statements that accurately describe this diagram.</p>",,,"The ratio of cups of white paint to cups of green paint is 2 to 4. || For every cup of green paint, there are two cups of white paint. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint. || <p>The ratio of cups of green paint to cups of white paint is 2 : 4.</p>","The ratio of cups of white paint to cups of green paint is 2 to 4. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint.",88681,9,4,1
+PRABE64M,1,Multiple Choice (select all),Check All That Apply,"<p>Here is a diagram that describes the cups of green and white paint in a mixture.</p>
+<p>&nbsp;</p>
+<table style=""height: 46px; width: 439px;"">
+<tbody>
+<tr>
+<td style=""width: 162.599px;"">green paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519919.jpg"" alt=""Four squares labeled &quot;green paint (cups)&quot;"" width=""200"" height=""43""></td>
+</tr>
+<tr>
+<td style=""width: 162.599px;"">white paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519920.jpg"" alt=""Two squares labeled &quot;white paint (cups)&quot;"" width=""200"" height=""50""></td>
+</tr>
+</tbody>
+</table>
+<p>&nbsp;</p>
+<p>Select&nbsp;<strong>all</strong> the statements that accurately describe this diagram.</p>",,,"The ratio of cups of white paint to cups of green paint is 2 to 4. || For every cup of green paint, there are two cups of white paint. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint. || <p>The ratio of cups of green paint to cups of white paint is 2 : 4.</p>","The ratio of cups of white paint to cups of green paint is 2 to 4. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint.",88681,9,4,1
+PRABE64M,1,Multiple Choice (select all),Check All That Apply,"<p>Here is a diagram that describes the cups of green and white paint in a mixture.</p>
+<p>&nbsp;</p>
+<table style=""height: 46px; width: 439px;"">
+<tbody>
+<tr>
+<td style=""width: 162.599px;"">green paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519919.jpg"" alt=""Four squares labeled &quot;green paint (cups)&quot;"" width=""200"" height=""43""></td>
+</tr>
+<tr>
+<td style=""width: 162.599px;"">white paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519920.jpg"" alt=""Two squares labeled &quot;white paint (cups)&quot;"" width=""200"" height=""50""></td>
+</tr>
+</tbody>
+</table>
+<p>&nbsp;</p>
+<p>Select&nbsp;<strong>all</strong> the statements that accurately describe this diagram.</p>",,,"The ratio of cups of white paint to cups of green paint is 2 to 4. || For every cup of green paint, there are two cups of white paint. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint. || <p>The ratio of cups of green paint to cups of white paint is 2 : 4.</p>","The ratio of cups of white paint to cups of green paint is 2 to 4. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint.",88681,9,4,1
+PRABE64M,1,Multiple Choice (select all),Check All That Apply,"<p>Here is a diagram that describes the cups of green and white paint in a mixture.</p>
+<p>&nbsp;</p>
+<table style=""height: 46px; width: 439px;"">
+<tbody>
+<tr>
+<td style=""width: 162.599px;"">green paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519919.jpg"" alt=""Four squares labeled &quot;green paint (cups)&quot;"" width=""200"" height=""43""></td>
+</tr>
+<tr>
+<td style=""width: 162.599px;"">white paint (cups)</td>
+<td style=""width: 259.401px;""><img src=""/images/assistments/519920.jpg"" alt=""Two squares labeled &quot;white paint (cups)&quot;"" width=""200"" height=""50""></td>
+</tr>
+</tbody>
+</table>
+<p>&nbsp;</p>
+<p>Select&nbsp;<strong>all</strong> the statements that accurately describe this diagram.</p>",,,"The ratio of cups of white paint to cups of green paint is 2 to 4. || For every cup of green paint, there are two cups of white paint. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint. || <p>The ratio of cups of green paint to cups of white paint is 2 : 4.</p>","The ratio of cups of white paint to cups of green paint is 2 to 4. || <p>The ratio of cups of green paint to cups of white paint is 4 : 2.</p> || For every cup of white paint, there are two cups of green paint.",88681,9,4,1
+PRABERFN,1,Multiple Choice (select 1),Multiple Choice,"<p>Which scale is equivalent to 1 cm to 1 km?</p>
+<div style=""position: absolute; left: 57px; top: 51px;"">&nbsp;</div>",,,"1 to 1,000 || 10,000 to 1 || 1 to 100,000 || 100,000 to 1 || 1 to 1,000,000","1 to 100,000",146478,10,2,1
+PRABERFN,1,Multiple Choice (select 1),Multiple Choice,"<p>Which scale is equivalent to 1 cm to 1 km?</p>
+<div style=""position: absolute; left: 57px; top: 51px;"">&nbsp;</div>",,,"1 to 1,000 || 10,000 to 1 || 1 to 100,000 || 100,000 to 1 || 1 to 1,000,000","1 to 100,000",146478,10,2,1
+PSB5BQ,1,Multiple Choice (select 1),Multiple Choice,"<p>In one version of trail mix, there are 3 cups of peanuts mixed with 2 cups of raisins. In another version of trail mix, there are 4.5 cups of peanuts mixed with 3 cups of raisins. Are the ratios equivalent for the two mixes?</p>",,,Yes || No,Yes,143888,11,2,1
+PSB5BQ,1,Multiple Choice (select 1),Multiple Choice,"<p>In one version of trail mix, there are 3 cups of peanuts mixed with 2 cups of raisins. In another version of trail mix, there are 4.5 cups of peanuts mixed with 3 cups of raisins. Are the ratios equivalent for the two mixes?</p>",,,Yes || No,Yes,143888,11,2,1
+PRABE55W,1,Multiple Choice (select all),Check All That Apply,<p>Select <strong>all</strong> the polygons.</p>,,,"<p><img src=""//resources.assistments.org/fetch/C/5001ccaa-f02f-4c1b-87b8-492ba85fe5be.jpeg"" alt=""Figure A"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/b0f7cbc8-accd-4c14-b0f5-b23ae3461ed5.jpeg"" alt=""Figure B"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/5995031e-500c-46c0-8dcb-26f5cbc80407.jpeg"" alt=""Figure C"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/0444903e-1fce-4e76-ac8d-35cb8f9a6e9e.jpeg"" alt=""Figure D"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/8ac8f6fa-3da0-4d32-8800-4f155bc611d7.jpeg"" alt=""Figure E"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/236cc5d3-5eb9-4f13-aaca-df2a9021603a.jpeg"" alt=""Figure F"" width=""200""></p>","<p><img src=""//resources.assistments.org/fetch/C/5001ccaa-f02f-4c1b-87b8-492ba85fe5be.jpeg"" alt=""Figure A"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/5995031e-500c-46c0-8dcb-26f5cbc80407.jpeg"" alt=""Figure C"" width=""200""></p>",243115,12,2,1
+PRABE55W,1,Multiple Choice (select all),Check All That Apply,<p>Select <strong>all</strong> the polygons.</p>,,,"<p><img src=""//resources.assistments.org/fetch/C/5001ccaa-f02f-4c1b-87b8-492ba85fe5be.jpeg"" alt=""Figure A"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/b0f7cbc8-accd-4c14-b0f5-b23ae3461ed5.jpeg"" alt=""Figure B"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/5995031e-500c-46c0-8dcb-26f5cbc80407.jpeg"" alt=""Figure C"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/0444903e-1fce-4e76-ac8d-35cb8f9a6e9e.jpeg"" alt=""Figure D"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/8ac8f6fa-3da0-4d32-8800-4f155bc611d7.jpeg"" alt=""Figure E"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/236cc5d3-5eb9-4f13-aaca-df2a9021603a.jpeg"" alt=""Figure F"" width=""200""></p>","<p><img src=""//resources.assistments.org/fetch/C/5001ccaa-f02f-4c1b-87b8-492ba85fe5be.jpeg"" alt=""Figure A"" width=""200""></p> || <p><img src=""//resources.assistments.org/fetch/C/5995031e-500c-46c0-8dcb-26f5cbc80407.jpeg"" alt=""Figure C"" width=""200""></p>",243115,12,2,1
+PRABP75T,1,Multiple Choice (select all),Check All That Apply,"<p>Salt and sugar give two distinctly different tastes, one salty and the other sweet.&nbsp;In a mixture of salt and sugar, it is possible for the mixture to be salty, sweet or both.&nbsp;Will any of these mixtures taste exactly the same?</p>",,,"Mixture A: 2 cups water, 4 teaspoons salt, 0.25 cup sugar || Mixture B: 1.5 cups water, 3 teaspoons salt, 0.2 cup sugar || Mixture C: 1 cup water, 2 teaspoons salt, 0.125 cup sugar || None of these mixtures taste the same.","Mixture A: 2 cups water, 4 teaspoons salt, 0.25 cup sugar || Mixture C: 1 cup water, 2 teaspoons salt, 0.125 cup sugar",48435,13,2,1
+PRABP75T,1,Multiple Choice (select all),Check All That Apply,"<p>Salt and sugar give two distinctly different tastes, one salty and the other sweet.&nbsp;In a mixture of salt and sugar, it is possible for the mixture to be salty, sweet or both.&nbsp;Will any of these mixtures taste exactly the same?</p>",,,"Mixture A: 2 cups water, 4 teaspoons salt, 0.25 cup sugar || Mixture B: 1.5 cups water, 3 teaspoons salt, 0.2 cup sugar || Mixture C: 1 cup water, 2 teaspoons salt, 0.125 cup sugar || None of these mixtures taste the same.","Mixture A: 2 cups water, 4 teaspoons salt, 0.25 cup sugar || Mixture C: 1 cup water, 2 teaspoons salt, 0.125 cup sugar",48435,13,2,1
+PSBGXA,1,Multiple Choice (select 1),Multiple Choice,<p>The side lengths of Triangle B are all 5 more than the side lengths of Triangle A. Can Triangle B be a scaled copy of Triangle A?</p>,,,Yes || No,Yes,36042,14,2,1
+PSBGXA,1,Multiple Choice (select 1),Multiple Choice,<p>The side lengths of Triangle B are all 5 more than the side lengths of Triangle A. Can Triangle B be a scaled copy of Triangle A?</p>,,,Yes || No,Yes,36042,14,2,1
+PRABMQH8,1,Multiple Choice (select all),Check All That Apply,"<p>Triangle Z is a scale copy of Triangle M.<br><br></p>
+<p><img src=""/images/assistments/274148.jpg"" alt=""Triangle M with side lengths of 4, 7, and 10."" width=""497"" height=""142""></p>
+<p><br>Select&nbsp;<strong>all</strong> the sets of values that could be the side lengths of Triangle Z.&nbsp;</p>",,,"<p>8,11,14</p> || 10,17.5,25 || 6,9,11 || 6,10.5,15 || 8,14,20","10,17.5,25 || 6,10.5,15 || 8,14,20",569234,15,2,1
+PRABMQH8,1,Multiple Choice (select all),Check All That Apply,"<p>Triangle Z is a scale copy of Triangle M.<br><br></p>
+<p><img src=""/images/assistments/274148.jpg"" alt=""Triangle M with side lengths of 4, 7, and 10."" width=""497"" height=""142""></p>
+<p><br>Select&nbsp;<strong>all</strong> the sets of values that could be the side lengths of Triangle Z.&nbsp;</p>",,,"<p>8,11,14</p> || 10,17.5,25 || 6,9,11 || 6,10.5,15 || 8,14,20","10,17.5,25 || 6,10.5,15 || 8,14,20",569234,15,2,1

Results/Problems_same_body_different_problem_id.csv

@@ -0,0 +1,55 @@
+Problem Set Id,Problem Part,Problem Type,Answer Types,Problem Body,Fill-in Options,Fill-in Answers,Multiple Choice Options,Multiple Choice Answers,problem_id,duplicate_group_id,distinct_problem_id_count,distinct_problem_ids
+PSB2CK,6,Fill-in-the-blank(s),Numeric,"<p>What is its&nbsp;answer?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r></p>",2.64,2.64,,,126628,1,3,126091;126362;126628
+PSB2CK,2,Fill-in-the-blank(s),Numeric,"<p>What is its&nbsp;answer?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r></p>",264,264,,,126091,1,3,126091;126362;126628
+PSB2CK,4,Fill-in-the-blank(s),Numeric,"<p>What is its&nbsp;answer?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r></p>",26.4,26.4,,,126362,1,3,126091;126362;126628
+PSBBS8M,2,Fill-in-the-blank(s),Numeric,"<p>How many different triangles are there?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> different triangles</p>",3,3,,,259177,2,2,258731;259177
+PSBBS6F,2,Fill-in-the-blank(s),Numeric,"<p>How many different triangles are there?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r> different triangles</p>",4,4,,,258731,2,2,258731;259177
+PRABFG57,1,Order / Sort,Ordering,<p>Order these numbers from least to greatest:</p>,"<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>1</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>1</mn><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>1</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>0</mn></math></p>","<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>1</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>1</mn><mfrac><mn>1</mn><mn>2</mn></mfrac></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>1</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>0</mn></math></p>",,,406337,3,2,406337;6158
+PRABFKN2,1,Order / Sort,Ordering,<p>Order these numbers from least to greatest:</p>,"<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>18</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>17</mn></mrow></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>18</mn></mrow></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mn>19</mn></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>20</mn></math></p>","<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>18</mn></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>17</mn></mrow></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>18</mn></mrow></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mn>19</mn></mfenced></math></p>, <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>20</mn></math></p>",,,6158,3,2,406337;6158
+PSBDASC,2,Fill-in-the-blank(s),Numeric,"<p>What is the decimal representation of that number?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r></p>",0.5,0.5,,,522651,4,2,522651;523084
+PSBDASC,6,Fill-in-the-blank(s),Numeric,"<p>What is the decimal representation of that number?</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r></p>",0.125,0.125,,,523084,4,2,522651;523084
+PSBCDYX,3,Fill-in-the-blank(s),Numeric,"<p>Solve the equation you wrote.</p>
+<p>&nbsp;</p>
+<p><em>x</em> = <ast-r type=""text"" marker=""1""></ast-r></p>",7.8,7.8,,,366764,5,2,366764;56163
+PSBMSN,3,Fill-in-the-blank(s),Numeric,"<p>Solve the equation you wrote.</p>
+<p>&nbsp;</p>
+<p><em>x</em> = <ast-r type=""text"" marker=""1""></ast-r></p>",11.6,11.6,,,56163,5,2,366764;56163
+PSBBSYB,2,Fill-in-the-blank(s),Numeric,"<p>If not, write it in scientific notation.</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>&#215;</mo><mn>10</mn></math><sup><ast-r type=""text"" marker=""2""></ast-r></sup></p>","6, 3.6","6, 3.6",,,257604,6,3,257097;257352;257604
+PSBBSWV,2,Fill-in-the-blank(s),Numeric,"<p>If not, write it in scientific notation.</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>&#215;</mo><mn>10</mn></math><sup><ast-r type=""text"" marker=""2""></ast-r></sup></p>","-4, 9.9","-4, 9.9",,,257352,6,3,257097;257352;257604
+PSBBSVC,2,Fill-in-the-blank(s),Numeric,"<p>If not, write it in scientific notation.</p>
+<p>&nbsp;</p>
+<p><ast-r type=""text"" marker=""1""></ast-r><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>&#215;</mo><mn>10</mn></math><sup><ast-r type=""text"" marker=""2""></ast-r></sup></p>","4, 4.82","4, 4.82",,,257097,6,3,257097;257352;257604
+PSBGBG,4,Fill-in-the-blank(s),Numeric,"<p>On which day did it occur?</p>
+<p>&nbsp;</p>
+<p>Day <ast-r type=""text"" marker=""1""></ast-r></p>",11,11,,,32600,7,2,32363;32600
+PSBGBG,2,Fill-in-the-blank(s),Numeric,"<p>On which day did it occur?</p>
+<p>&nbsp;</p>
+<p>Day <ast-r type=""text"" marker=""1""></ast-r></p>",14,14,,,32363,7,2,32363;32600
+PRABQM8U,1,Multiple Choice (select all),Check All That Apply,<p>Select&nbsp;<strong>all</strong>&nbsp;the true statements.</p>,,,"Given a box plot, it is always possible to calculate the mean of the data. || Given a box plot, it is always possible to calculate the median of the data. || Given a box plot, it is always possible to construct a corresponding dot plot. || Given a dot plot, it is always possible to construct a corresponding box plot. || Given a histogram, it is always possible to construct a corresponding box plot.","Given a box plot, it is always possible to calculate the median of the data. || Given a dot plot, it is always possible to construct a corresponding box plot.",193572,8,3,193572;362112;69320
+PRABEVAG,1,Multiple Choice (select all),Check All That Apply,<p>Select&nbsp;<strong>all</strong>&nbsp;the true statements.</p>,,,"<p>2.3 + (-2.3) is equal to zero.</p> || <p>(-3.7) + (-4.1) is positive.</p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>2</mn><mo>.</mo><mn>6</mn><mo>&#160;</mo><mo>-</mo><mo>&#160;</mo><mfenced><mrow><mo>-</mo><mfrac><mn>12</mn><mn>4</mn></mfrac></mrow></mfenced><mo>&#160;</mo><mi>is</mi><mo>&#160;</mo><mi>positive</mi></math>.</p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced><mfrac><mn>5</mn><mn>2</mn></mfrac></mfenced><mo>&#160;</mo><mo>+</mo><mo>&#160;</mo><mfenced><mrow><mo>-</mo><mn>2</mn><mo>.</mo><mn>5</mn></mrow></mfenced><mo>&#160;</mo><mi>is</mi><mo>&#160;</mo><mi>negative</mi></math>.</p> || <p>72 - (-100) is negative.</p>","<p>2.3 + (-2.3) is equal to zero.</p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>2</mn><mo>.</mo><mn>6</mn><mo>&#160;</mo><mo>-</mo><mo>&#160;</mo><mfenced><mrow><mo>-</mo><mfrac><mn>12</mn><mn>4</mn></mfrac></mrow></mfenced><mo>&#160;</mo><mi>is</mi><mo>&#160;</mo><mi>positive</mi></math>.</p>",69320,8,3,193572;362112;69320
+PRABFJP8,1,Multiple Choice (select all),Check All That Apply,<p>Select&nbsp;<strong>all</strong>&nbsp;the true statements.</p>,,,"<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>5</mn><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>5</mn></mrow></mfenced></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>6</mn></mrow></mfenced><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mo>-</mo><mn>5</mn></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>6</mn></mrow></mfenced><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mn>3</mn></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>4</mn><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>7</mn></mrow></mfenced></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>7</mn></mrow></mfenced><mo>&#160;</mo><mo>&#60;</mo><mo>&#160;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>8</mn></mrow></mfenced></math></p>","<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mo>-</mo><mn>5</mn><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>5</mn></mrow></mfenced></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>4</mn><mo>&nbsp;</mo><mo>&lt;</mo><mo>&nbsp;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>7</mn></mrow></mfenced></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>7</mn></mrow></mfenced><mo>&#160;</mo><mo>&#60;</mo><mo>&#160;</mo><mfenced open=""|"" close=""|""><mrow><mo>-</mo><mn>8</mn></mrow></mfenced></math></p>",362112,8,3,193572;362112;69320
+PSBCKT6,1,Multiple Choice (select 1),Multiple Choice,"<p>For the pair of numbers below, select the number that is greater.</p>",,,"<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>42</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>7</mn></msup></math></p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>8</mn><mo>.</mo><mn>5</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>8</mn></msup></math></p>","<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>8</mn><mo>.</mo><mn>5</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>8</mn></msup></math></p>",399091,9,3,398365;398730;399091
+PSBCKRX,1,Multiple Choice (select 1),Multiple Choice,"<p>For the pair of numbers below, select the number that is greater.</p>",,,"<p><span><span><span><span><span><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>2</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>6</mn></msup></math></span></span></span></span></span>&nbsp;</p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>7</mn><mo>.</mo><mn>839</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>6</mn></msup></math><span><span><span><span></span></span></span></span>&nbsp;</p>","<p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>7</mn><mo>.</mo><mn>839</mn><mo>&nbsp;</mo><mo>·</mo><mo>&nbsp;</mo><msup><mn>10</mn><mn>6</mn></msup></math><span><span><span><span></span></span></span></span>&nbsp;</p>",398730,9,3,398365;398730;399091
+PSBCKP4,1,Multiple Choice (select 1),Multiple Choice,"<p>For the pair of numbers below, select the number that is greater.</p>",,,"<p><span><span><span><span><span><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>17</mn><mo>·</mo><msup><mn>10</mn><mn>8</mn></msup></math></span></span></span></span></span>&nbsp; &nbsp;</p> || <p><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>4</mn><mo>·</mo><msup><mn>10</mn><mn>8</mn></msup></math></p>","<p><span><span><span><span><span><math xmlns=""http://www.w3.org/1998/Math/MathML""><mn>17</mn><mo>·</mo><msup><mn>10</mn><mn>8</mn></msup></math></span></span></span></span></span>&nbsp; &nbsp;</p>",398365,9,3,398365;398730;399091
+PRABQPRF,1,Multiple Choice (select 1),Multiple Choice,<p>Which of these describes a unique polygon?</p>,,,"A quadrilateral with 4 right angles || A triangle with angles 30°, 80°, and 70° || A triangle with side lengths 7 cm and 8 cm and a 70° angle || A triangle with each side length 5 inches",A triangle with each side length 5 inches,558308,10,2,483667;558308
+PRABEVDM,1,Multiple Choice (select 1),Multiple Choice,<p>Which of these describes a unique polygon?</p>,,,"A triangle with angles&nbsp;30°,&nbsp;50°, and&nbsp;100° || A quadrilateral with each side length 5 cm || A triangle with side lengths 6 cm, 7 cm, and 8 cm || A triangle with side lengths 4 cm and 5 cm and a&nbsp;50°&nbsp;angle","A triangle with side lengths 6 cm, 7 cm, and 8 cm",483667,10,2,483667;558308
+PSBBD9R,2,Multiple Choice (select 1),Multiple Choice,<p>Which group shows greater variability?</p>,,,<p>Group A</p> || group B,<p>Group A</p>,193337,11,2,193337;529063
+PSBDBQU,2,Multiple Choice (select 1),Multiple Choice,<p>Which group shows greater variability?</p>,,,Group A || Group B,Group A,529063,11,2,193337;529063

Results/day_student_attempt_distribution_counts_00173df52c65a9c13b45978c5a56ea2db67b17deded674486f7af64f7c5fd9ac.csv

@@ -0,0 +1,262 @@
+bin_left_min,bin_right_min,bin_width_min,attempt_count,probability,percentage
+0.0,1440.0,1440.0,1,0.002617801047120419,0.2617801047120419
+1440.0,2880.0,1440.0,2,0.005235602094240838,0.5235602094240838
+2880.0,4320.0,1440.0,1,0.002617801047120419,0.2617801047120419
+4320.0,5760.0,1440.0,0,0.0,0.0
+5760.0,7200.0,1440.0,0,0.0,0.0
+7200.0,8640.0,1440.0,0,0.0,0.0
+8640.0,10080.0,1440.0,0,0.0,0.0
+10080.0,11520.0,1440.0,0,0.0,0.0
+11520.0,12960.0,1440.0,3,0.007853403141361256,0.7853403141361256
+12960.0,14400.0,1440.0,0,0.0,0.0
+14400.0,15840.0,1440.0,0,0.0,0.0
+15840.0,17280.0,1440.0,6,0.015706806282722512,1.5706806282722512
+17280.0,18720.0,1440.0,0,0.0,0.0
+18720.0,20160.0,1440.0,0,0.0,0.0
+20160.0,21600.0,1440.0,2,0.005235602094240838,0.5235602094240838
+21600.0,23040.0,1440.0,3,0.007853403141361256,0.7853403141361256
+23040.0,24480.0,1440.0,0,0.0,0.0
+24480.0,25920.0,1440.0,0,0.0,0.0
+25920.0,27360.0,1440.0,8,0.020942408376963352,2.094240837696335
+27360.0,28800.0,1440.0,0,0.0,0.0
+28800.0,30240.0,1440.0,0,0.0,0.0
+30240.0,31680.0,1440.0,0,0.0,0.0
+31680.0,33120.0,1440.0,1,0.002617801047120419,0.2617801047120419
+33120.0,34560.0,1440.0,1,0.002617801047120419,0.2617801047120419
+34560.0,36000.0,1440.0,4,0.010471204188481676,1.0471204188481675
+36000.0,37440.0,1440.0,1,0.002617801047120419,0.2617801047120419
+37440.0,38880.0,1440.0,0,0.0,0.0
+38880.0,40320.0,1440.0,0,0.0,0.0
+40320.0,41760.0,1440.0,0,0.0,0.0
+41760.0,43200.0,1440.0,0,0.0,0.0
+43200.0,44640.0,1440.0,1,0.002617801047120419,0.2617801047120419
+44640.0,46080.0,1440.0,0,0.0,0.0
+46080.0,47520.0,1440.0,0,0.0,0.0
+47520.0,48960.0,1440.0,0,0.0,0.0
+48960.0,50400.0,1440.0,0,0.0,0.0
+50400.0,51840.0,1440.0,9,0.02356020942408377,2.356020942408377
+51840.0,53280.0,1440.0,0,0.0,0.0
+53280.0,54720.0,1440.0,0,0.0,0.0
+54720.0,56160.0,1440.0,0,0.0,0.0
+56160.0,57600.0,1440.0,0,0.0,0.0
+57600.0,59040.0,1440.0,0,0.0,0.0
+59040.0,60480.0,1440.0,0,0.0,0.0
+60480.0,61920.0,1440.0,6,0.015706806282722512,1.5706806282722512
+61920.0,63360.0,1440.0,3,0.007853403141361256,0.7853403141361256
+63360.0,64800.0,1440.0,8,0.020942408376963352,2.094240837696335
+64800.0,66240.0,1440.0,8,0.020942408376963352,2.094240837696335
+66240.0,67680.0,1440.0,0,0.0,0.0
+67680.0,69120.0,1440.0,0,0.0,0.0
+69120.0,70560.0,1440.0,2,0.005235602094240838,0.5235602094240838
+70560.0,72000.0,1440.0,12,0.031413612565445025,3.1413612565445024
+72000.0,73440.0,1440.0,9,0.02356020942408377,2.356020942408377
+73440.0,74880.0,1440.0,3,0.007853403141361256,0.7853403141361256
+74880.0,76320.0,1440.0,6,0.015706806282722512,1.5706806282722512
+76320.0,77760.0,1440.0,0,0.0,0.0
+77760.0,79200.0,1440.0,0,0.0,0.0
+79200.0,80640.0,1440.0,0,0.0,0.0
+80640.0,82080.0,1440.0,0,0.0,0.0
+82080.0,83520.0,1440.0,0,0.0,0.0
+83520.0,84960.0,1440.0,0,0.0,0.0
+84960.0,86400.0,1440.0,0,0.0,0.0
+86400.0,87840.0,1440.0,0,0.0,0.0
+87840.0,89280.0,1440.0,0,0.0,0.0
+89280.0,90720.0,1440.0,0,0.0,0.0
+90720.0,92160.0,1440.0,0,0.0,0.0
+92160.0,93600.0,1440.0,1,0.002617801047120419,0.2617801047120419
+93600.0,95040.0,1440.0,1,0.002617801047120419,0.2617801047120419
+95040.0,96480.0,1440.0,0,0.0,0.0
+96480.0,97920.0,1440.0,1,0.002617801047120419,0.2617801047120419
+97920.0,99360.0,1440.0,0,0.0,0.0
+99360.0,100800.0,1440.0,0,0.0,0.0
+100800.0,102240.0,1440.0,0,0.0,0.0
+102240.0,103680.0,1440.0,3,0.007853403141361256,0.7853403141361256
+103680.0,105120.0,1440.0,8,0.020942408376963352,2.094240837696335
+105120.0,106560.0,1440.0,0,0.0,0.0
+106560.0,108000.0,1440.0,0,0.0,0.0
+108000.0,109440.0,1440.0,0,0.0,0.0
+109440.0,110880.0,1440.0,3,0.007853403141361256,0.7853403141361256
+110880.0,112320.0,1440.0,0,0.0,0.0
+112320.0,113760.0,1440.0,0,0.0,0.0
+113760.0,115200.0,1440.0,0,0.0,0.0
+115200.0,116640.0,1440.0,7,0.01832460732984293,1.832460732984293
+116640.0,118080.0,1440.0,1,0.002617801047120419,0.2617801047120419
+118080.0,119520.0,1440.0,0,0.0,0.0
+119520.0,120960.0,1440.0,0,0.0,0.0
+120960.0,122400.0,1440.0,0,0.0,0.0
+122400.0,123840.0,1440.0,0,0.0,0.0
+123840.0,125280.0,1440.0,8,0.020942408376963352,2.094240837696335
+125280.0,126720.0,1440.0,3,0.007853403141361256,0.7853403141361256
+126720.0,128160.0,1440.0,0,0.0,0.0
+128160.0,129600.0,1440.0,0,0.0,0.0
+129600.0,131040.0,1440.0,10,0.02617801047120419,2.6178010471204187
+131040.0,132480.0,1440.0,3,0.007853403141361256,0.7853403141361256
+132480.0,133920.0,1440.0,14,0.03664921465968586,3.664921465968586
+133920.0,135360.0,1440.0,0,0.0,0.0
+135360.0,136800.0,1440.0,1,0.002617801047120419,0.2617801047120419
+136800.0,138240.0,1440.0,1,0.002617801047120419,0.2617801047120419
+138240.0,139680.0,1440.0,0,0.0,0.0
+139680.0,141120.0,1440.0,1,0.002617801047120419,0.2617801047120419
+141120.0,142560.0,1440.0,0,0.0,0.0
+142560.0,144000.0,1440.0,0,0.0,0.0
+144000.0,145440.0,1440.0,1,0.002617801047120419,0.2617801047120419
+145440.0,146880.0,1440.0,0,0.0,0.0
+146880.0,148320.0,1440.0,0,0.0,0.0
+148320.0,149760.0,1440.0,0,0.0,0.0
+149760.0,151200.0,1440.0,0,0.0,0.0
+151200.0,152640.0,1440.0,0,0.0,0.0
+152640.0,154080.0,1440.0,0,0.0,0.0
+154080.0,155520.0,1440.0,0,0.0,0.0
+155520.0,156960.0,1440.0,0,0.0,0.0
+156960.0,158400.0,1440.0,0,0.0,0.0
+158400.0,159840.0,1440.0,0,0.0,0.0
+159840.0,161280.0,1440.0,0,0.0,0.0
+161280.0,162720.0,1440.0,0,0.0,0.0
+162720.0,164160.0,1440.0,7,0.01832460732984293,1.832460732984293
+164160.0,165600.0,1440.0,3,0.007853403141361256,0.7853403141361256
+165600.0,167040.0,1440.0,7,0.01832460732984293,1.832460732984293
+167040.0,168480.0,1440.0,0,0.0,0.0
+168480.0,169920.0,1440.0,0,0.0,0.0
+169920.0,171360.0,1440.0,1,0.002617801047120419,0.2617801047120419
+171360.0,172800.0,1440.0,5,0.013089005235602094,1.3089005235602094
+172800.0,174240.0,1440.0,7,0.01832460732984293,1.832460732984293
+174240.0,175680.0,1440.0,3,0.007853403141361256,0.7853403141361256
+175680.0,177120.0,1440.0,0,0.0,0.0
+177120.0,178560.0,1440.0,0,0.0,0.0
+178560.0,180000.0,1440.0,0,0.0,0.0
+180000.0,181440.0,1440.0,2,0.005235602094240838,0.5235602094240838
+181440.0,182880.0,1440.0,9,0.02356020942408377,2.356020942408377
+182880.0,184320.0,1440.0,2,0.005235602094240838,0.5235602094240838
+184320.0,185760.0,1440.0,0,0.0,0.0
+185760.0,187200.0,1440.0,0,0.0,0.0
+187200.0,188640.0,1440.0,0,0.0,0.0
+188640.0,190080.0,1440.0,0,0.0,0.0
+190080.0,191520.0,1440.0,0,0.0,0.0
+191520.0,192960.0,1440.0,0,0.0,0.0
+192960.0,194400.0,1440.0,0,0.0,0.0
+194400.0,195840.0,1440.0,0,0.0,0.0
+195840.0,197280.0,1440.0,0,0.0,0.0
+197280.0,198720.0,1440.0,0,0.0,0.0
+198720.0,200160.0,1440.0,0,0.0,0.0
+200160.0,201600.0,1440.0,0,0.0,0.0
+201600.0,203040.0,1440.0,0,0.0,0.0
+203040.0,204480.0,1440.0,0,0.0,0.0
+204480.0,205920.0,1440.0,0,0.0,0.0
+205920.0,207360.0,1440.0,0,0.0,0.0
+207360.0,208800.0,1440.0,0,0.0,0.0
+208800.0,210240.0,1440.0,0,0.0,0.0
+210240.0,211680.0,1440.0,0,0.0,0.0
+211680.0,213120.0,1440.0,0,0.0,0.0
+213120.0,214560.0,1440.0,2,0.005235602094240838,0.5235602094240838
+214560.0,216000.0,1440.0,1,0.002617801047120419,0.2617801047120419
+216000.0,217440.0,1440.0,8,0.020942408376963352,2.094240837696335
+217440.0,218880.0,1440.0,6,0.015706806282722512,1.5706806282722512
+218880.0,220320.0,1440.0,0,0.0,0.0
+220320.0,221760.0,1440.0,2,0.005235602094240838,0.5235602094240838
+221760.0,223200.0,1440.0,3,0.007853403141361256,0.7853403141361256
+223200.0,224640.0,1440.0,3,0.007853403141361256,0.7853403141361256
+224640.0,226080.0,1440.0,0,0.0,0.0
+226080.0,227520.0,1440.0,1,0.002617801047120419,0.2617801047120419
+227520.0,228960.0,1440.0,0,0.0,0.0
+228960.0,230400.0,1440.0,0,0.0,0.0
+230400.0,231840.0,1440.0,0,0.0,0.0
+231840.0,233280.0,1440.0,0,0.0,0.0
+233280.0,234720.0,1440.0,6,0.015706806282722512,1.5706806282722512
+234720.0,236160.0,1440.0,8,0.020942408376963352,2.094240837696335
+236160.0,237600.0,1440.0,1,0.002617801047120419,0.2617801047120419
+237600.0,239040.0,1440.0,4,0.010471204188481676,1.0471204188481675
+239040.0,240480.0,1440.0,0,0.0,0.0
+240480.0,241920.0,1440.0,0,0.0,0.0
+241920.0,243360.0,1440.0,2,0.005235602094240838,0.5235602094240838
+243360.0,244800.0,1440.0,3,0.007853403141361256,0.7853403141361256
+244800.0,246240.0,1440.0,4,0.010471204188481676,1.0471204188481675
+246240.0,247680.0,1440.0,2,0.005235602094240838,0.5235602094240838
+247680.0,249120.0,1440.0,1,0.002617801047120419,0.2617801047120419
+249120.0,250560.0,1440.0,0,0.0,0.0
+250560.0,252000.0,1440.0,1,0.002617801047120419,0.2617801047120419
+252000.0,253440.0,1440.0,0,0.0,0.0
+253440.0,254880.0,1440.0,0,0.0,0.0
+254880.0,256320.0,1440.0,0,0.0,0.0
+256320.0,257760.0,1440.0,4,0.010471204188481676,1.0471204188481675
+257760.0,259200.0,1440.0,4,0.010471204188481676,1.0471204188481675
+259200.0,260640.0,1440.0,0,0.0,0.0
+260640.0,262080.0,1440.0,0,0.0,0.0
+262080.0,263520.0,1440.0,5,0.013089005235602094,1.3089005235602094
+263520.0,264960.0,1440.0,2,0.005235602094240838,0.5235602094240838
+264960.0,266400.0,1440.0,2,0.005235602094240838,0.5235602094240838
+266400.0,267840.0,1440.0,0,0.0,0.0
+267840.0,269280.0,1440.0,0,0.0,0.0
+269280.0,270720.0,1440.0,0,0.0,0.0
+270720.0,272160.0,1440.0,6,0.015706806282722512,1.5706806282722512
+272160.0,273600.0,1440.0,0,0.0,0.0
+273600.0,275040.0,1440.0,4,0.010471204188481676,1.0471204188481675
+275040.0,276480.0,1440.0,0,0.0,0.0
+276480.0,277920.0,1440.0,0,0.0,0.0
+277920.0,279360.0,1440.0,0,0.0,0.0
+279360.0,280800.0,1440.0,0,0.0,0.0
+280800.0,282240.0,1440.0,0,0.0,0.0
+282240.0,283680.0,1440.0,4,0.010471204188481676,1.0471204188481675
+283680.0,285120.0,1440.0,0,0.0,0.0
+285120.0,286560.0,1440.0,0,0.0,0.0
+286560.0,288000.0,1440.0,7,0.01832460732984293,1.832460732984293
+288000.0,289440.0,1440.0,0,0.0,0.0
+289440.0,290880.0,1440.0,0,0.0,0.0
+290880.0,292320.0,1440.0,0,0.0,0.0
+292320.0,293760.0,1440.0,5,0.013089005235602094,1.3089005235602094
+293760.0,295200.0,1440.0,1,0.002617801047120419,0.2617801047120419
+295200.0,296640.0,1440.0,6,0.015706806282722512,1.5706806282722512
+296640.0,298080.0,1440.0,6,0.015706806282722512,1.5706806282722512
+298080.0,299520.0,1440.0,5,0.013089005235602094,1.3089005235602094
+299520.0,300960.0,1440.0,0,0.0,0.0
+300960.0,302400.0,1440.0,0,0.0,0.0
+302400.0,303840.0,1440.0,6,0.015706806282722512,1.5706806282722512
+303840.0,305280.0,1440.0,17,0.04450261780104712,4.450261780104712
+305280.0,306720.0,1440.0,0,0.0,0.0
+306720.0,308160.0,1440.0,8,0.020942408376963352,2.094240837696335
+308160.0,309600.0,1440.0,0,0.0,0.0
+309600.0,311040.0,1440.0,0,0.0,0.0
+311040.0,312480.0,1440.0,0,0.0,0.0
+312480.0,313920.0,1440.0,0,0.0,0.0
+313920.0,315360.0,1440.0,0,0.0,0.0
+315360.0,316800.0,1440.0,0,0.0,0.0
+316800.0,318240.0,1440.0,0,0.0,0.0
+318240.0,319680.0,1440.0,0,0.0,0.0
+319680.0,321120.0,1440.0,0,0.0,0.0
+321120.0,322560.0,1440.0,0,0.0,0.0
+322560.0,324000.0,1440.0,1,0.002617801047120419,0.2617801047120419
+324000.0,325440.0,1440.0,3,0.007853403141361256,0.7853403141361256
+325440.0,326880.0,1440.0,0,0.0,0.0
+326880.0,328320.0,1440.0,4,0.010471204188481676,1.0471204188481675
+328320.0,329760.0,1440.0,1,0.002617801047120419,0.2617801047120419
+329760.0,331200.0,1440.0,0,0.0,0.0
+331200.0,332640.0,1440.0,0,0.0,0.0
+332640.0,334080.0,1440.0,0,0.0,0.0
+334080.0,335520.0,1440.0,0,0.0,0.0
+335520.0,336960.0,1440.0,0,0.0,0.0
+336960.0,338400.0,1440.0,0,0.0,0.0
+338400.0,339840.0,1440.0,0,0.0,0.0
+339840.0,341280.0,1440.0,0,0.0,0.0
+341280.0,342720.0,1440.0,0,0.0,0.0
+342720.0,344160.0,1440.0,0,0.0,0.0
+344160.0,345600.0,1440.0,0,0.0,0.0
+345600.0,347040.0,1440.0,0,0.0,0.0
+347040.0,348480.0,1440.0,0,0.0,0.0
+348480.0,349920.0,1440.0,0,0.0,0.0
+349920.0,351360.0,1440.0,0,0.0,0.0
+351360.0,352800.0,1440.0,0,0.0,0.0
+352800.0,354240.0,1440.0,0,0.0,0.0
+354240.0,355680.0,1440.0,0,0.0,0.0
+355680.0,357120.0,1440.0,0,0.0,0.0
+357120.0,358560.0,1440.0,5,0.013089005235602094,1.3089005235602094
+358560.0,360000.0,1440.0,0,0.0,0.0
+360000.0,361440.0,1440.0,0,0.0,0.0
+361440.0,362880.0,1440.0,0,0.0,0.0
+362880.0,364320.0,1440.0,0,0.0,0.0
+364320.0,365760.0,1440.0,0,0.0,0.0
+365760.0,367200.0,1440.0,0,0.0,0.0
+367200.0,368640.0,1440.0,1,0.002617801047120419,0.2617801047120419
+368640.0,370080.0,1440.0,0,0.0,0.0
+370080.0,371520.0,1440.0,0,0.0,0.0
+371520.0,372960.0,1440.0,1,0.002617801047120419,0.2617801047120419
+372960.0,374400.0,1440.0,1,0.002617801047120419,0.2617801047120419
+374400.0,375840.0,1440.0,2,0.005235602094240838,0.5235602094240838

Results/day_student_attempt_distribution_counts_001849d40d6bf1e2ed5826e4420e291e54655a2b6b77a9ab701faaeb4e899abe.csv

@@ -0,0 +1,256 @@
+bin_left_min,bin_right_min,bin_width_min,attempt_count,probability,percentage
+0.0,1440.0,1440.0,4,0.010958904109589041,1.095890410958904
+1440.0,2880.0,1440.0,4,0.010958904109589041,1.095890410958904
+2880.0,4320.0,1440.0,1,0.0027397260273972603,0.273972602739726
+4320.0,5760.0,1440.0,2,0.005479452054794521,0.547945205479452
+5760.0,7200.0,1440.0,0,0.0,0.0
+7200.0,8640.0,1440.0,0,0.0,0.0
+8640.0,10080.0,1440.0,4,0.010958904109589041,1.095890410958904
+10080.0,11520.0,1440.0,5,0.0136986301369863,1.36986301369863
+11520.0,12960.0,1440.0,1,0.0027397260273972603,0.273972602739726
+12960.0,14400.0,1440.0,5,0.0136986301369863,1.36986301369863
+14400.0,15840.0,1440.0,2,0.005479452054794521,0.547945205479452
+15840.0,17280.0,1440.0,0,0.0,0.0
+17280.0,18720.0,1440.0,0,0.0,0.0
+18720.0,20160.0,1440.0,6,0.01643835616438356,1.643835616438356
+20160.0,21600.0,1440.0,3,0.00821917808219178,0.821917808219178
+21600.0,23040.0,1440.0,2,0.005479452054794521,0.547945205479452
+23040.0,24480.0,1440.0,2,0.005479452054794521,0.547945205479452
+24480.0,25920.0,1440.0,1,0.0027397260273972603,0.273972602739726
+25920.0,27360.0,1440.0,0,0.0,0.0
+27360.0,28800.0,1440.0,0,0.0,0.0
+28800.0,30240.0,1440.0,5,0.0136986301369863,1.36986301369863
+30240.0,31680.0,1440.0,0,0.0,0.0
+31680.0,33120.0,1440.0,0,0.0,0.0
+33120.0,34560.0,1440.0,1,0.0027397260273972603,0.273972602739726
+34560.0,36000.0,1440.0,16,0.043835616438356165,4.383561643835616
+36000.0,37440.0,1440.0,0,0.0,0.0
+37440.0,38880.0,1440.0,0,0.0,0.0
+38880.0,40320.0,1440.0,1,0.0027397260273972603,0.273972602739726
+40320.0,41760.0,1440.0,0,0.0,0.0
+41760.0,43200.0,1440.0,2,0.005479452054794521,0.547945205479452
+43200.0,44640.0,1440.0,0,0.0,0.0
+44640.0,46080.0,1440.0,1,0.0027397260273972603,0.273972602739726
+46080.0,47520.0,1440.0,0,0.0,0.0
+47520.0,48960.0,1440.0,0,0.0,0.0
+48960.0,50400.0,1440.0,4,0.010958904109589041,1.095890410958904
+50400.0,51840.0,1440.0,1,0.0027397260273972603,0.273972602739726
+51840.0,53280.0,1440.0,2,0.005479452054794521,0.547945205479452
+53280.0,54720.0,1440.0,2,0.005479452054794521,0.547945205479452
+54720.0,56160.0,1440.0,2,0.005479452054794521,0.547945205479452
+56160.0,57600.0,1440.0,0,0.0,0.0
+57600.0,59040.0,1440.0,0,0.0,0.0
+59040.0,60480.0,1440.0,0,0.0,0.0
+60480.0,61920.0,1440.0,2,0.005479452054794521,0.547945205479452
+61920.0,63360.0,1440.0,0,0.0,0.0
+63360.0,64800.0,1440.0,0,0.0,0.0
+64800.0,66240.0,1440.0,0,0.0,0.0
+66240.0,67680.0,1440.0,0,0.0,0.0
+67680.0,69120.0,1440.0,0,0.0,0.0
+69120.0,70560.0,1440.0,2,0.005479452054794521,0.547945205479452
+70560.0,72000.0,1440.0,3,0.00821917808219178,0.821917808219178
+72000.0,73440.0,1440.0,3,0.00821917808219178,0.821917808219178
+73440.0,74880.0,1440.0,7,0.019178082191780823,1.9178082191780823
+74880.0,76320.0,1440.0,3,0.00821917808219178,0.821917808219178
+76320.0,77760.0,1440.0,0,0.0,0.0
+77760.0,79200.0,1440.0,0,0.0,0.0
+79200.0,80640.0,1440.0,2,0.005479452054794521,0.547945205479452
+80640.0,82080.0,1440.0,8,0.021917808219178082,2.191780821917808
+82080.0,83520.0,1440.0,2,0.005479452054794521,0.547945205479452
+83520.0,84960.0,1440.0,4,0.010958904109589041,1.095890410958904
+84960.0,86400.0,1440.0,0,0.0,0.0
+86400.0,87840.0,1440.0,0,0.0,0.0
+87840.0,89280.0,1440.0,0,0.0,0.0
+89280.0,90720.0,1440.0,4,0.010958904109589041,1.095890410958904
+90720.0,92160.0,1440.0,0,0.0,0.0
+92160.0,93600.0,1440.0,6,0.01643835616438356,1.643835616438356
+93600.0,95040.0,1440.0,0,0.0,0.0
+95040.0,96480.0,1440.0,4,0.010958904109589041,1.095890410958904
+96480.0,97920.0,1440.0,0,0.0,0.0
+97920.0,99360.0,1440.0,0,0.0,0.0
+99360.0,100800.0,1440.0,0,0.0,0.0
+100800.0,102240.0,1440.0,3,0.00821917808219178,0.821917808219178
+102240.0,103680.0,1440.0,6,0.01643835616438356,1.643835616438356
+103680.0,105120.0,1440.0,3,0.00821917808219178,0.821917808219178
+105120.0,106560.0,1440.0,1,0.0027397260273972603,0.273972602739726
+106560.0,108000.0,1440.0,0,0.0,0.0
+108000.0,109440.0,1440.0,0,0.0,0.0
+109440.0,110880.0,1440.0,0,0.0,0.0
+110880.0,112320.0,1440.0,0,0.0,0.0
+112320.0,113760.0,1440.0,0,0.0,0.0
+113760.0,115200.0,1440.0,0,0.0,0.0
+115200.0,116640.0,1440.0,0,0.0,0.0
+116640.0,118080.0,1440.0,0,0.0,0.0
+118080.0,119520.0,1440.0,0,0.0,0.0
+119520.0,120960.0,1440.0,1,0.0027397260273972603,0.273972602739726
+120960.0,122400.0,1440.0,3,0.00821917808219178,0.821917808219178
+122400.0,123840.0,1440.0,2,0.005479452054794521,0.547945205479452
+123840.0,125280.0,1440.0,5,0.0136986301369863,1.36986301369863
+125280.0,126720.0,1440.0,3,0.00821917808219178,0.821917808219178
+126720.0,128160.0,1440.0,0,0.0,0.0
+128160.0,129600.0,1440.0,0,0.0,0.0
+129600.0,131040.0,1440.0,8,0.021917808219178082,2.191780821917808
+131040.0,132480.0,1440.0,5,0.0136986301369863,1.36986301369863
+132480.0,133920.0,1440.0,4,0.010958904109589041,1.095890410958904
+133920.0,135360.0,1440.0,6,0.01643835616438356,1.643835616438356
+135360.0,136800.0,1440.0,4,0.010958904109589041,1.095890410958904
+136800.0,138240.0,1440.0,0,0.0,0.0
+138240.0,139680.0,1440.0,0,0.0,0.0
+139680.0,141120.0,1440.0,0,0.0,0.0
+141120.0,142560.0,1440.0,0,0.0,0.0
+142560.0,144000.0,1440.0,0,0.0,0.0
+144000.0,145440.0,1440.0,0,0.0,0.0
+145440.0,146880.0,1440.0,0,0.0,0.0
+146880.0,148320.0,1440.0,0,0.0,0.0
+148320.0,149760.0,1440.0,0,0.0,0.0
+149760.0,151200.0,1440.0,0,0.0,0.0
+151200.0,152640.0,1440.0,0,0.0,0.0
+152640.0,154080.0,1440.0,0,0.0,0.0
+154080.0,155520.0,1440.0,0,0.0,0.0
+155520.0,156960.0,1440.0,0,0.0,0.0
+156960.0,158400.0,1440.0,0,0.0,0.0
+158400.0,159840.0,1440.0,0,0.0,0.0
+159840.0,161280.0,1440.0,0,0.0,0.0
+161280.0,162720.0,1440.0,0,0.0,0.0
+162720.0,164160.0,1440.0,0,0.0,0.0
+164160.0,165600.0,1440.0,0,0.0,0.0
+165600.0,167040.0,1440.0,0,0.0,0.0
+167040.0,168480.0,1440.0,0,0.0,0.0
+168480.0,169920.0,1440.0,0,0.0,0.0
+169920.0,171360.0,1440.0,0,0.0,0.0
+171360.0,172800.0,1440.0,0,0.0,0.0
+172800.0,174240.0,1440.0,0,0.0,0.0
+174240.0,175680.0,1440.0,0,0.0,0.0
+175680.0,177120.0,1440.0,0,0.0,0.0
+177120.0,178560.0,1440.0,0,0.0,0.0
+178560.0,180000.0,1440.0,0,0.0,0.0
+180000.0,181440.0,1440.0,3,0.00821917808219178,0.821917808219178
+181440.0,182880.0,1440.0,7,0.019178082191780823,1.9178082191780823
+182880.0,184320.0,1440.0,0,0.0,0.0
+184320.0,185760.0,1440.0,8,0.021917808219178082,2.191780821917808
+185760.0,187200.0,1440.0,5,0.0136986301369863,1.36986301369863
+187200.0,188640.0,1440.0,0,0.0,0.0
+188640.0,190080.0,1440.0,0,0.0,0.0
+190080.0,191520.0,1440.0,0,0.0,0.0
+191520.0,192960.0,1440.0,3,0.00821917808219178,0.821917808219178
+192960.0,194400.0,1440.0,0,0.0,0.0
+194400.0,195840.0,1440.0,2,0.005479452054794521,0.547945205479452
+195840.0,197280.0,1440.0,0,0.0,0.0
+197280.0,198720.0,1440.0,0,0.0,0.0
+198720.0,200160.0,1440.0,0,0.0,0.0
+200160.0,201600.0,1440.0,3,0.00821917808219178,0.821917808219178
+201600.0,203040.0,1440.0,1,0.0027397260273972603,0.273972602739726
+203040.0,204480.0,1440.0,4,0.010958904109589041,1.095890410958904
+204480.0,205920.0,1440.0,8,0.021917808219178082,2.191780821917808
+205920.0,207360.0,1440.0,0,0.0,0.0
+207360.0,208800.0,1440.0,0,0.0,0.0
+208800.0,210240.0,1440.0,0,0.0,0.0
+210240.0,211680.0,1440.0,2,0.005479452054794521,0.547945205479452
+211680.0,213120.0,1440.0,2,0.005479452054794521,0.547945205479452
+213120.0,214560.0,1440.0,0,0.0,0.0
+214560.0,216000.0,1440.0,5,0.0136986301369863,1.36986301369863
+216000.0,217440.0,1440.0,3,0.00821917808219178,0.821917808219178
+217440.0,218880.0,1440.0,0,0.0,0.0
+218880.0,220320.0,1440.0,0,0.0,0.0
+220320.0,221760.0,1440.0,4,0.010958904109589041,1.095890410958904
+221760.0,223200.0,1440.0,5,0.0136986301369863,1.36986301369863
+223200.0,224640.0,1440.0,6,0.01643835616438356,1.643835616438356
+224640.0,226080.0,1440.0,0,0.0,0.0
+226080.0,227520.0,1440.0,0,0.0,0.0
+227520.0,228960.0,1440.0,0,0.0,0.0
+228960.0,230400.0,1440.0,0,0.0,0.0
+230400.0,231840.0,1440.0,0,0.0,0.0
+231840.0,233280.0,1440.0,4,0.010958904109589041,1.095890410958904
+233280.0,234720.0,1440.0,0,0.0,0.0
+234720.0,236160.0,1440.0,1,0.0027397260273972603,0.273972602739726
+236160.0,237600.0,1440.0,0,0.0,0.0
+237600.0,239040.0,1440.0,0,0.0,0.0
+239040.0,240480.0,1440.0,0,0.0,0.0
+240480.0,241920.0,1440.0,0,0.0,0.0
+241920.0,243360.0,1440.0,0,0.0,0.0
+243360.0,244800.0,1440.0,6,0.01643835616438356,1.643835616438356
+244800.0,246240.0,1440.0,5,0.0136986301369863,1.36986301369863
+246240.0,247680.0,1440.0,0,0.0,0.0
+247680.0,249120.0,1440.0,0,0.0,0.0
+249120.0,250560.0,1440.0,0,0.0,0.0
+250560.0,252000.0,1440.0,0,0.0,0.0
+252000.0,253440.0,1440.0,0,0.0,0.0
+253440.0,254880.0,1440.0,0,0.0,0.0
+254880.0,256320.0,1440.0,0,0.0,0.0
+256320.0,257760.0,1440.0,3,0.00821917808219178,0.821917808219178
+257760.0,259200.0,1440.0,0,0.0,0.0
+259200.0,260640.0,1440.0,0,0.0,0.0
+260640.0,262080.0,1440.0,2,0.005479452054794521,0.547945205479452
+262080.0,263520.0,1440.0,0,0.0,0.0
+263520.0,264960.0,1440.0,0,0.0,0.0
+264960.0,266400.0,1440.0,2,0.005479452054794521,0.547945205479452
+266400.0,267840.0,1440.0,6,0.01643835616438356,1.643835616438356
+267840.0,269280.0,1440.0,0,0.0,0.0
+269280.0,270720.0,1440.0,0,0.0,0.0
+270720.0,272160.0,1440.0,4,0.010958904109589041,1.095890410958904
+272160.0,273600.0,1440.0,0,0.0,0.0
+273600.0,275040.0,1440.0,4,0.010958904109589041,1.095890410958904
+275040.0,276480.0,1440.0,5,0.0136986301369863,1.36986301369863
+276480.0,277920.0,1440.0,0,0.0,0.0
+277920.0,279360.0,1440.0,0,0.0,0.0
+279360.0,280800.0,1440.0,0,0.0,0.0
+280800.0,282240.0,1440.0,0,0.0,0.0
+282240.0,283680.0,1440.0,0,0.0,0.0
+283680.0,285120.0,1440.0,0,0.0,0.0
+285120.0,286560.0,1440.0,0,0.0,0.0
+286560.0,288000.0,1440.0,0,0.0,0.0
+288000.0,289440.0,1440.0,0,0.0,0.0
+289440.0,290880.0,1440.0,0,0.0,0.0
+290880.0,292320.0,1440.0,0,0.0,0.0
+292320.0,293760.0,1440.0,1,0.0027397260273972603,0.273972602739726
+293760.0,295200.0,1440.0,0,0.0,0.0
+295200.0,296640.0,1440.0,0,0.0,0.0
+296640.0,298080.0,1440.0,0,0.0,0.0
+298080.0,299520.0,1440.0,0,0.0,0.0
+299520.0,300960.0,1440.0,0,0.0,0.0
+300960.0,302400.0,1440.0,2,0.005479452054794521,0.547945205479452
+302400.0,303840.0,1440.0,2,0.005479452054794521,0.547945205479452
+303840.0,305280.0,1440.0,3,0.00821917808219178,0.821917808219178
+305280.0,306720.0,1440.0,6,0.01643835616438356,1.643835616438356
+306720.0,308160.0,1440.0,4,0.010958904109589041,1.095890410958904
+308160.0,309600.0,1440.0,0,0.0,0.0
+309600.0,311040.0,1440.0,0,0.0,0.0
+311040.0,312480.0,1440.0,4,0.010958904109589041,1.095890410958904
+312480.0,313920.0,1440.0,6,0.01643835616438356,1.643835616438356
+313920.0,315360.0,1440.0,4,0.010958904109589041,1.095890410958904
+315360.0,316800.0,1440.0,0,0.0,0.0
+316800.0,318240.0,1440.0,0,0.0,0.0
+318240.0,319680.0,1440.0,0,0.0,0.0
+319680.0,321120.0,1440.0,0,0.0,0.0
+321120.0,322560.0,1440.0,0,0.0,0.0
+322560.0,324000.0,1440.0,0,0.0,0.0
+324000.0,325440.0,1440.0,0,0.0,0.0
+325440.0,326880.0,1440.0,0,0.0,0.0
+326880.0,328320.0,1440.0,0,0.0,0.0
+328320.0,329760.0,1440.0,0,0.0,0.0
+329760.0,331200.0,1440.0,0,0.0,0.0
+331200.0,332640.0,1440.0,6,0.01643835616438356,1.643835616438356
+332640.0,334080.0,1440.0,4,0.010958904109589041,1.095890410958904
+334080.0,335520.0,1440.0,1,0.0027397260273972603,0.273972602739726
+335520.0,336960.0,1440.0,1,0.0027397260273972603,0.273972602739726
+336960.0,338400.0,1440.0,1,0.0027397260273972603,0.273972602739726
+338400.0,339840.0,1440.0,0,0.0,0.0
+339840.0,341280.0,1440.0,0,0.0,0.0
+341280.0,342720.0,1440.0,1,0.0027397260273972603,0.273972602739726
+342720.0,344160.0,1440.0,0,0.0,0.0
+344160.0,345600.0,1440.0,5,0.0136986301369863,1.36986301369863
+345600.0,347040.0,1440.0,9,0.024657534246575342,2.4657534246575343
+347040.0,348480.0,1440.0,0,0.0,0.0
+348480.0,349920.0,1440.0,0,0.0,0.0
+349920.0,351360.0,1440.0,0,0.0,0.0
+351360.0,352800.0,1440.0,0,0.0,0.0
+352800.0,354240.0,1440.0,0,0.0,0.0
+354240.0,355680.0,1440.0,0,0.0,0.0
+355680.0,357120.0,1440.0,0,0.0,0.0
+357120.0,358560.0,1440.0,0,0.0,0.0
+358560.0,360000.0,1440.0,0,0.0,0.0
+360000.0,361440.0,1440.0,0,0.0,0.0
+361440.0,362880.0,1440.0,3,0.00821917808219178,0.821917808219178
+362880.0,364320.0,1440.0,3,0.00821917808219178,0.821917808219178
+364320.0,365760.0,1440.0,2,0.005479452054794521,0.547945205479452
+365760.0,367200.0,1440.0,1,0.0027397260273972603,0.273972602739726

Results/inference_data_kt_results.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5ecb945b29f013a0da9f770266b80724f4f9d92da04e41357b69f309622d0ea
+size 2080602643

Results/month_student_attempt_distribution_counts.csv

@@ -0,0 +1,69 @@
+bin_left_min,bin_right_min,bin_width_min,attempt_count,probability,percentage
+0.0,43200.0,43200.0,209461,0.1198159238984321,11.98159238984321
+43200.0,86400.0,43200.0,177545,0.1015593270754323,10.155932707543231
+86400.0,129600.0,43200.0,176130,0.10074991848712096,10.074991848712097
+129600.0,172800.0,43200.0,167676,0.09591405968458806,9.591405968458806
+172800.0,216000.0,43200.0,155115,0.08872891390523913,8.872891390523913
+216000.0,259200.0,43200.0,174585,0.09986614727232165,9.986614727232165
+259200.0,302400.0,43200.0,189411,0.10834691881317249,10.834691881317248
+302400.0,345600.0,43200.0,125970,0.07205738506684056,7.205738506684057
+345600.0,388800.0,43200.0,97012,0.055492824006543914,5.549282400654391
+388800.0,432000.0,43200.0,28306,0.016191603887449304,1.6191603887449304
+432000.0,475200.0,43200.0,18574,0.010624703264519303,1.0624703264519304
+475200.0,518400.0,43200.0,24530,0.014031655598075725,1.4031655598075725
+518400.0,561600.0,43200.0,29081,0.016634919545358343,1.6634919545358344
+561600.0,604800.0,43200.0,29056,0.016620619040264503,1.6620619040264504
+604800.0,648000.0,43200.0,23457,0.013417877919448115,1.3417877919448116
+648000.0,691200.0,43200.0,23176,0.013257140242193355,1.3257140242193355
+691200.0,734400.0,43200.0,21084,0.01206047397594083,1.206047397594083
+734400.0,777600.0,43200.0,21215,0.012135408622632552,1.213540862263255
+777600.0,820800.0,43200.0,20921,0.011967234682728993,1.1967234682728993
+820800.0,864000.0,43200.0,13592,0.007774898609418885,0.7774898609418884
+864000.0,907200.0,43200.0,10107,0.0057814081993376,0.57814081993376
+907200.0,950400.0,43200.0,1273,0.0007281817193783284,0.07281817193783284
+950400.0,993600.0,43200.0,1086,0.0006212139412764059,0.06212139412764059
+993600.0,1036800.0,43200.0,1155,0.000660683335335404,0.0660683335335404
+1036800.0,1080000.0,43200.0,1266,0.0007241775779520533,0.07241775779520533
+1080000.0,1123200.0,43200.0,1494,0.0008545981844078733,0.08545981844078733
+1123200.0,1166400.0,43200.0,810,0.0004633363650404132,0.04633363650404132
+1166400.0,1209600.0,43200.0,730,0.0004175747487401255,0.04175747487401255
+1209600.0,1252800.0,43200.0,362,0.00020707131375880195,0.020707131375880195
+1252800.0,1296000.0,43200.0,1075,0.0006149217190351163,0.06149217190351163
+1296000.0,1339200.0,43200.0,716,0.00040956646588757514,0.040956646588757514
+1339200.0,1382400.0,43200.0,972,0.0005560036380484959,0.05560036380484959
+1382400.0,1425600.0,43200.0,817,0.0004673405064666884,0.04673405064666884
+1425600.0,1468800.0,43200.0,258,0.00014758121256842793,0.014758121256842793
+1468800.0,1512000.0,43200.0,4,2.288080815014386e-06,0.00022880808150143862
+1512000.0,1555200.0,43200.0,5,2.8601010187679828e-06,0.0002860101018767983
+1555200.0,1598400.0,43200.0,0,0.0,0.0
+1598400.0,1641600.0,43200.0,0,0.0,0.0
+1641600.0,1684800.0,43200.0,10,5.7202020375359656e-06,0.0005720202037535966
+1684800.0,1728000.0,43200.0,1,5.720202037535965e-07,5.7202020375359656e-05
+1728000.0,1771200.0,43200.0,0,0.0,0.0
+1771200.0,1814400.0,43200.0,3,1.7160606112607897e-06,0.00017160606112607898
+1814400.0,1857600.0,43200.0,0,0.0,0.0
+1857600.0,1900800.0,43200.0,0,0.0,0.0
+1900800.0,1944000.0,43200.0,0,0.0,0.0
+1944000.0,1987200.0,43200.0,0,0.0,0.0
+1987200.0,2030400.0,43200.0,0,0.0,0.0
+2030400.0,2073600.0,43200.0,0,0.0,0.0
+2073600.0,2116800.0,43200.0,2,1.144040407507193e-06,0.00011440404075071931
+2116800.0,2160000.0,43200.0,3,1.7160606112607897e-06,0.00017160606112607898
+2160000.0,2203200.0,43200.0,5,2.8601010187679828e-06,0.0002860101018767983
+2203200.0,2246400.0,43200.0,11,6.292222241289563e-06,0.0006292222241289563
+2246400.0,2289600.0,43200.0,19,1.0868383871318335e-05,0.0010868383871318334
+2289600.0,2332800.0,43200.0,5,2.8601010187679828e-06,0.0002860101018767983
+2332800.0,2376000.0,43200.0,12,6.864242445043159e-06,0.0006864242445043159
+2376000.0,2419200.0,43200.0,11,6.292222241289563e-06,0.0006292222241289563
+2419200.0,2462400.0,43200.0,9,5.148181833782369e-06,0.000514818183378237
+2462400.0,2505600.0,43200.0,4,2.288080815014386e-06,0.00022880808150143862
+2505600.0,2548800.0,43200.0,0,0.0,0.0
+2548800.0,2592000.0,43200.0,8,4.576161630028772e-06,0.00045761616300287725
+2592000.0,2635200.0,43200.0,18,1.0296363667564739e-05,0.001029636366756474
+2635200.0,2678400.0,43200.0,13,7.436262648796756e-06,0.0007436262648796755
+2678400.0,2721600.0,43200.0,11,6.292222241289563e-06,0.0006292222241289563
+2721600.0,2764800.0,43200.0,0,0.0,0.0
+2764800.0,2808000.0,43200.0,0,0.0,0.0
+2808000.0,2851200.0,43200.0,4,2.288080815014386e-06,0.00022880808150143862
+2851200.0,2894400.0,43200.0,3,1.7160606112607897e-06,0.00017160606112607898
+2894400.0,2937600.0,43200.0,11,6.292222241289563e-06,0.0006292222241289563

Results/month_student_attempt_distribution_counts_00173df52c65a9c13b45978c5a56ea2db67b17deded674486f7af64f7c5fd9ac.csv

@@ -0,0 +1,10 @@
+bin_left_min,bin_right_min,bin_width_min,attempt_count,probability,percentage
+0.0,43200.0,43200.0,33,0.08638743455497382,8.638743455497382
+43200.0,86400.0,43200.0,67,0.17539267015706805,17.539267015706805
+86400.0,129600.0,43200.0,36,0.09424083769633508,9.424083769633508
+129600.0,172800.0,43200.0,54,0.14136125654450263,14.136125654450263
+172800.0,216000.0,43200.0,26,0.06806282722513089,6.806282722513089
+216000.0,259200.0,43200.0,63,0.1649214659685864,16.49214659685864
+259200.0,302400.0,43200.0,53,0.1387434554973822,13.874345549738221
+302400.0,345600.0,43200.0,40,0.10471204188481675,10.471204188481675
+345600.0,388800.0,43200.0,10,0.02617801047120419,2.6178010471204187

Results/month_student_attempt_distribution_counts_001849d40d6bf1e2ed5826e4420e291e54655a2b6b77a9ab701faaeb4e899abe.csv

@@ -0,0 +1,10 @@
+bin_left_min,bin_right_min,bin_width_min,attempt_count,probability,percentage
+0.0,43200.0,43200.0,67,0.18356164383561643,18.356164383561644
+43200.0,86400.0,43200.0,48,0.13150684931506848,13.150684931506849
+86400.0,129600.0,43200.0,41,0.11232876712328767,11.232876712328768
+129600.0,172800.0,43200.0,27,0.07397260273972603,7.397260273972603
+172800.0,216000.0,43200.0,53,0.14520547945205478,14.520547945205479
+216000.0,259200.0,43200.0,37,0.10136986301369863,10.136986301369863
+259200.0,302400.0,43200.0,26,0.07123287671232877,7.123287671232877
+302400.0,345600.0,43200.0,48,0.13150684931506848,13.150684931506849
+345600.0,388800.0,43200.0,18,0.049315068493150684,4.931506849315069

Results/pedagogical_grounding/README.md

@@ -0,0 +1,275 @@
+# Pedagogical Grounding
+
+This module provides tools for analyzing educational assessment data and benchmarking LLMs on pedagogical reasoning tasks.
+
+## Overview
+
+The pedagogical grounding work consists of two parts:
+
+1. **Analysis Scripts** - Compute pedagogical metrics from student response data
+2. **LLM Benchmark** - Evaluate LLMs on pedagogical reasoning tasks
+
+---
+
+## Part 1: Analysis Scripts
+
+These scripts analyze the FoundationalKT dataset to compute pedagogical metrics.
+
+### IRT Parameters (`irt_parameters.py`)
+
+Computes Item Response Theory parameters for assessment items using Bayesian inference.
+
+```bash
+python pedagogical_grounding/irt_parameters.py \
+    --data-dir foundationalktdataset/ \
+    --output-dir pedagogical_grounding/output/
+```
+
+**Output:** `irt_parameters.json` (~2,548 problems)
+
+| Field | Description |
+|-------|-------------|
+| `problem_id` | Unique problem identifier |
+| `difficulty_1pl` | 1PL (Rasch) difficulty parameter |
+| `difficulty_2pl` | 2PL difficulty parameter (primary metric) |
+| `discrimination_2pl` | 2PL discrimination parameter |
+| `percent_correct` | Empirical accuracy rate |
+| `n_responses` | Number of student responses |
+
+**Interpretation:**
+- `difficulty_2pl`: Higher = harder (range: -1.35 to 0.91)
+- `discrimination_2pl`: Higher = better at distinguishing student ability (range: 0.01 to 0.91)
+
+### Distractor Analysis (`distractor_analysis.py`)
+
+Analyzes the effectiveness of wrong answer choices in multiple-choice questions.
+
+```bash
+python pedagogical_grounding/distractor_analysis.py \
+    --data-dir foundationalktdataset/ \
+    --output-dir pedagogical_grounding/output/
+```
+
+**Output:** `distractor_stats.json` (~236 MC problems)
+
+| Field | Description |
+|-------|-------------|
+| `problem_id` | Unique problem identifier |
+| `n_choices` | Number of answer options |
+| `correct_rate` | Fraction choosing correct answer |
+| `distractors` | Dict of wrong answers → count |
+| `distractor_frequencies` | Dict of wrong answers → frequency |
+| `most_common_distractor` | Most frequently chosen wrong answer |
+| `least_common_distractor` | Least frequently chosen wrong answer |
+
+---
+
+## Part 2: LLM Benchmark
+
+Benchmarks LLMs on 4 pedagogical reasoning tasks using zero-shot evaluation.
+
+### Tasks
+
+| Task | Description | Data Source | Metric |
+|------|-------------|-------------|--------|
+| `difficulty` | Which of two questions is harder? | IRT params | Binary accuracy |
+| `discrimination` | Which question better distinguishes ability? | IRT params | Binary accuracy |
+| `distractor_most` | Which wrong answer is most commonly chosen? | Distractor stats | Multi-class accuracy |
+| `distractor_least` | Which wrong answer is least commonly chosen? | Distractor stats | Multi-class accuracy |
+
+### Scripts
+
+All benchmark scripts are located in this folder (`pedagogical_grounding/`):
+
+| File | Description |
+|------|-------------|
+| `pedagogical_inference_base.py` | Base module with data loading, sampling, prompts, inference |
+| `gptoss120b_pedagogical.py` | GPT-OSS-120B model config |
+| `qwen3next80b_instruct_pedagogical.py` | Qwen3-Next-80B-Instruct model config |
+| `qwen3next80b_thinking_pedagogical.py` | Qwen3-Next-80B-Thinking model config |
+| `evaluate_pedagogical.py` | Evaluation script for accuracy metrics |
+
+### Usage
+
+**Run all commands from the project root directory.**
+
+#### Run Inference
+
+```bash
+# Difficulty comparison (stratified sampling, 1000 pairs)
+CUDA_VISIBLE_DEVICES=0,1,2,3 python pedagogical_grounding/gptoss120b_pedagogical.py \
+    --task difficulty \
+    --num-samples 1000 \
+    --sampling-mode stratified \
+    --num-gpus 4
+
+# Discrimination comparison
+CUDA_VISIBLE_DEVICES=0,1,2,3 python pedagogical_grounding/gptoss120b_pedagogical.py \
+    --task discrimination \
+    --num-samples 1000 \
+    --num-gpus 4
+
+# Most common distractor prediction
+CUDA_VISIBLE_DEVICES=0,1,2,3 python pedagogical_grounding/gptoss120b_pedagogical.py \
+    --task distractor_most \
+    --num-gpus 4
+
+# Least common distractor prediction
+CUDA_VISIBLE_DEVICES=0,1,2,3 python pedagogical_grounding/gptoss120b_pedagogical.py \
+    --task distractor_least \
+    --num-gpus 4
+
+# All tasks at once
+CUDA_VISIBLE_DEVICES=0,1,2,3 python pedagogical_grounding/gptoss120b_pedagogical.py \
+    --task all \
+    --num-samples 500 \
+    --num-gpus 4
+```
+
+#### Evaluate Results
+
+```bash
+python pedagogical_grounding/evaluate_pedagogical.py --input gptoss120b_pedagogical_difficulty_n1000_stratified.jsonl
+python pedagogical_grounding/evaluate_pedagogical.py --input results.jsonl --output metrics.json
+```
+
+### CLI Arguments
+
+| Argument | Description | Default |
+|----------|-------------|---------|
+| `--task` | Task to run: `difficulty`, `discrimination`, `distractor_most`, `distractor_least`, `all` | Required |
+| `--sampling-mode` | `random` or `stratified` (ensures meaningful differences) | `stratified` |
+| `--num-samples` | Number of pairs/problems to sample | 1000 |
+| `--min-difference` | Minimum difference for stratified sampling | 0.2 |
+| `--batch-size` | Batch size for vLLM inference | 500 |
+| `--num-gpus` | Number of GPUs for tensor parallelism | 1 |
+| `--data-dir` | Base directory containing data files | `.` |
+
+### Sampling Modes
+
+**Random:** Any two questions randomly paired (may include trivial comparisons).
+
+**Stratified:** Ensures meaningful differences between pairs:
+- Small: 0.2–0.5 difference
+- Medium: 0.5–1.0 difference
+- Large: >1.0 difference
+
+### Output Format (JSONL)
+
+**Comparison tasks:**
+```json
+{
+  "prediction_id": "difficulty_405080_448452",
+  "task": "difficulty",
+  "problem_id_a": 405080,
+  "problem_id_b": 448452,
+  "value_a": -0.234,
+  "value_b": -0.533,
+  "difference": 0.299,
+  "stratum": "small",
+  "ground_truth": "A",
+  "predicted_answer": "A",
+  "is_correct": true
+}
+```
+
+**Distractor tasks:**
+```json
+{
+  "prediction_id": "distractor_most_74236",
+  "task": "distractor_most",
+  "problem_id": 74236,
+  "n_choices": 4,
+  "ground_truth_letter": "B",
+  "ground_truth_text": "Elena is correct",
+  "ground_truth_freq": 0.207,
+  "predicted_answer": "B",
+  "is_correct": true
+}
+```
+
+### Baselines
+
+| Task | Random Baseline |
+|------|-----------------|
+| Difficulty comparison | 50% |
+| Discrimination comparison | 50% |
+| Distractor (3 options) | 33% |
+| Distractor (4 options) | 25% |
+
+### Evaluation Metrics
+
+The evaluation script computes:
+
+- **Overall accuracy** vs random baseline
+- **By stratum** (for comparison tasks): small/medium/large difference
+- **By difference magnitude**: very_small/small/medium/large
+- **By number of distractors** (for distractor tasks)
+- **By ground truth frequency**: rare/moderate/common distractors
+
+---
+
+## Data Flow
+
+```
+foundationalktdataset/
+├── Interactions.csv          # Student responses
+├── Problems.csv         # Problem text and answers
+└── Skills.csv             # Skill metadata
+        │
+        ▼
+┌───────────────────────────────────────┐
+│     Analysis Scripts (Part 1)         │
+│  irt_parameters.py, distractor_analysis.py │
+└───────────────────────────────────────┘
+        │
+        ▼
+pedagogical_grounding/output/
+├── irt_parameters.json    # 2,548 problems with IRT params
+└── distractor_stats.json  # 236 MC problems with distractor data
+        │
+        ▼
+┌───────────────────────────────────────┐
+│      LLM Benchmark (Part 2)           │
+│  pedagogical_inference_base.py        │
+│  + model configs                      │
+└───────────────────────────────────────┘
+        │
+        ▼
+Output: JSONL predictions + evaluation metrics
+```
+
+---
+
+## File Structure
+
+```
+foundationalKT-ss/
+├── pedagogical_grounding/
+│   ├── README.md                         # This file
+│   │
+│   │   # Analysis Scripts (Part 1)
+│   ├── irt_parameters.py                 # IRT parameter computation
+│   ├── distractor_analysis.py            # Distractor effectiveness analysis
+│   │
+│   │   # LLM Benchmark (Part 2)
+│   ├── pedagogical_inference_base.py     # Benchmark base module
+│   ├── gptoss120b_pedagogical.py         # GPT-OSS-120B config
+│   ├── qwen3next80b_instruct_pedagogical.py  # Qwen3 Instruct config
+│   ├── qwen3next80b_thinking_pedagogical.py  # Qwen3 Thinking config
+│   ├── evaluate_pedagogical.py           # Evaluation script
+│   │
+│   │   # Output Data
+│   └── output/
+│       ├── irt_parameters.json           # IRT results (2,548 problems)
+│       ├── irt_parameters.png            # IRT visualizations
+│       ├── distractor_stats.json         # Distractor results (236 problems)
+│       └── distractor_analysis.png       # Distractor visualizations
+│
+├── foundationalktdataset/                # Source data
+│   ├── Interactions.csv
+│   ├── Problems.csv
+│   └── Skills.csv
+│
+└── clean_utils.py                        # Text cleaning utilities
+```

Results/pedagogical_grounding/batch_evaluate.py

@@ -0,0 +1,328 @@
+"""
+Batch evaluation script for Pedagogical Grounding LLM Benchmark.
+
+Analyzes all result files in a directory and creates aggregate comparison tables.
+
+Usage:
+    python pedagogical_grounding/batch_evaluate.py --input-dir pedagogical_grounding/results
+    python pedagogical_grounding/batch_evaluate.py --input-dir results --output summary.json
+"""
+
+import argparse
+import glob
+import json
+import os
+import re
+from collections import defaultdict
+from typing import Dict, List, Tuple
+
+from evaluate_pedagogical import (
+    load_results,
+    evaluate_comparison_task,
+    evaluate_distractor_task,
+)
+
+
+def extract_model_name(filename: str) -> str:
+    """Extract model name from filename."""
+    basename = os.path.basename(filename)
+    # Pattern: {model}_pedagogical_{task}_...
+    match = re.match(r'^(.+?)_pedagogical_', basename)
+    if match:
+        return match.group(1)
+    return basename.replace('.jsonl', '')
+
+
+def evaluate_file(filepath: str) -> Tuple[str, Dict]:
+    """Evaluate a single file and return model name and metrics."""
+    model_name = extract_model_name(filepath)
+    results = load_results(filepath)
+
+    metrics = {
+        'file': os.path.basename(filepath),
+        'total_predictions': len(results),
+        'tasks': {}
+    }
+
+    # Identify and evaluate tasks
+    tasks = set(r.get('task') for r in results if r.get('task'))
+
+    for task in tasks:
+        if task in ['difficulty', 'discrimination']:
+            task_metrics = evaluate_comparison_task(results, task)
+        elif task in ['distractor_most', 'distractor_least']:
+            task_metrics = evaluate_distractor_task(results, task)
+        else:
+            continue
+
+        if 'error' not in task_metrics:
+            metrics['tasks'][task] = task_metrics
+
+    return model_name, metrics
+
+
+def print_header(title: str, width: int = 80) -> None:
+    """Print a formatted header."""
+    print()
+    print("=" * width)
+    print(f" {title}")
+    print("=" * width)
+
+
+def print_accuracy_table(all_metrics: Dict[str, Dict], task: str) -> None:
+    """Print accuracy comparison table for a task."""
+    models = sorted(all_metrics.keys())
+
+    # Get baseline
+    if task in ['difficulty', 'discrimination']:
+        baseline = 0.5
+        baseline_label = "50.0%"
+    else:
+        baseline = None  # Varies by model
+        baseline_label = "varies"
+
+    # Header
+    print(f"\n{'Model':<35} {'Accuracy':>10} {'Lift':>10} {'N':>8}")
+    print("-" * 65)
+
+    # Data rows
+    for model in models:
+        task_metrics = all_metrics[model]['tasks'].get(task)
+        if task_metrics and 'error' not in task_metrics:
+            acc = task_metrics['accuracy']
+            lift = task_metrics['lift_over_random']
+            n = task_metrics['total']
+            print(f"{model:<35} {acc:>9.1%} {lift:>+9.1%} {n:>8}")
+        else:
+            print(f"{model:<35} {'N/A':>10} {'N/A':>10} {'N/A':>8}")
+
+    print("-" * 65)
+    print(f"{'Random Baseline':<35} {baseline_label:>10}")
+
+
+def print_stratum_table(all_metrics: Dict[str, Dict], task: str) -> None:
+    """Print stratum breakdown comparison table."""
+    models = sorted(all_metrics.keys())
+    strata = ['small', 'medium', 'large']
+
+    # Header
+    header = f"{'Model':<30}"
+    for s in strata:
+        header += f" {s:>12}"
+    print(f"\n{header}")
+    print("-" * (30 + 13 * len(strata)))
+
+    # Data rows
+    for model in models:
+        task_metrics = all_metrics[model]['tasks'].get(task)
+        if task_metrics and 'error' not in task_metrics:
+            row = f"{model:<30}"
+            by_stratum = task_metrics.get('by_stratum', {})
+            for s in strata:
+                if s in by_stratum:
+                    acc = by_stratum[s]['accuracy']
+                    row += f" {acc:>11.1%}"
+                else:
+                    row += f" {'N/A':>12}"
+            print(row)
+
+
+def print_summary_table(all_metrics: Dict[str, Dict]) -> None:
+    """Print overall summary table with all tasks."""
+    models = sorted(all_metrics.keys())
+    tasks = ['difficulty', 'discrimination', 'distractor_most', 'distractor_least']
+    task_abbrev = {
+        'difficulty': 'Diff',
+        'discrimination': 'Disc',
+        'distractor_most': 'D-Most',
+        'distractor_least': 'D-Least'
+    }
+
+    # Header
+    header = f"{'Model':<30}"
+    for t in tasks:
+        header += f" {task_abbrev[t]:>10}"
+    header += f" {'Avg':>10}"
+    print(f"\n{header}")
+    print("-" * (30 + 11 * (len(tasks) + 1)))
+
+    # Data rows
+    for model in models:
+        row = f"{model:<30}"
+        accs = []
+        for t in tasks:
+            task_metrics = all_metrics[model]['tasks'].get(t)
+            if task_metrics and 'error' not in task_metrics:
+                acc = task_metrics['accuracy']
+                row += f" {acc:>9.1%}"
+                accs.append(acc)
+            else:
+                row += f" {'N/A':>10}"
+
+        # Average
+        if accs:
+            avg = sum(accs) / len(accs)
+            row += f" {avg:>9.1%}"
+        else:
+            row += f" {'N/A':>10}"
+
+        print(row)
+
+    # Baseline row
+    print("-" * (30 + 11 * (len(tasks) + 1)))
+    baseline_row = f"{'Random Baseline':<30}"
+    baseline_row += f" {'50.0%':>10}"  # difficulty
+    baseline_row += f" {'50.0%':>10}"  # discrimination
+    baseline_row += f" {'~35%':>10}"   # distractor_most
+    baseline_row += f" {'~35%':>10}"   # distractor_least
+    baseline_row += f" {'~43%':>10}"   # avg
+    print(baseline_row)
+
+
+def print_lift_table(all_metrics: Dict[str, Dict]) -> None:
+    """Print lift over random baseline table."""
+    models = sorted(all_metrics.keys())
+    tasks = ['difficulty', 'discrimination', 'distractor_most', 'distractor_least']
+    task_abbrev = {
+        'difficulty': 'Diff',
+        'discrimination': 'Disc',
+        'distractor_most': 'D-Most',
+        'distractor_least': 'D-Least'
+    }
+
+    # Header
+    header = f"{'Model':<30}"
+    for t in tasks:
+        header += f" {task_abbrev[t]:>10}"
+    header += f" {'Avg Lift':>10}"
+    print(f"\n{header}")
+    print("-" * (30 + 11 * (len(tasks) + 1)))
+
+    # Data rows
+    for model in models:
+        row = f"{model:<30}"
+        lifts = []
+        for t in tasks:
+            task_metrics = all_metrics[model]['tasks'].get(t)
+            if task_metrics and 'error' not in task_metrics:
+                lift = task_metrics['lift_over_random']
+                row += f" {lift:>+9.1%}"
+                lifts.append(lift)
+            else:
+                row += f" {'N/A':>10}"
+
+        # Average lift
+        if lifts:
+            avg_lift = sum(lifts) / len(lifts)
+            row += f" {avg_lift:>+9.1%}"
+        else:
+            row += f" {'N/A':>10}"
+
+        print(row)
+
+
+def print_best_model_per_task(all_metrics: Dict[str, Dict]) -> None:
+    """Print best model for each task."""
+    tasks = ['difficulty', 'discrimination', 'distractor_most', 'distractor_least']
+
+    print(f"\n{'Task':<20} {'Best Model':<30} {'Accuracy':>10} {'Lift':>10}")
+    print("-" * 72)
+
+    for task in tasks:
+        best_model = None
+        best_acc = -1
+        best_lift = 0
+
+        for model, metrics in all_metrics.items():
+            task_metrics = metrics['tasks'].get(task)
+            if task_metrics and 'error' not in task_metrics:
+                if task_metrics['accuracy'] > best_acc:
+                    best_acc = task_metrics['accuracy']
+                    best_lift = task_metrics['lift_over_random']
+                    best_model = model
+
+        if best_model:
+            print(f"{task:<20} {best_model:<30} {best_acc:>9.1%} {best_lift:>+9.1%}")
+        else:
+            print(f"{task:<20} {'N/A':<30} {'N/A':>10} {'N/A':>10}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Batch evaluate Pedagogical Grounding Benchmark results"
+    )
+    parser.add_argument(
+        "--input-dir", "-i",
+        type=str,
+        required=True,
+        help="Directory containing JSONL result files"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        type=str,
+        default=None,
+        help="Output JSON file for aggregate metrics (optional)"
+    )
+    parser.add_argument(
+        "--pattern",
+        type=str,
+        default="*.jsonl",
+        help="Glob pattern for result files (default: *.jsonl)"
+    )
+    args = parser.parse_args()
+
+    # Find all result files
+    pattern = os.path.join(args.input_dir, args.pattern)
+    files = sorted(glob.glob(pattern))
+
+    if not files:
+        print(f"No files found matching: {pattern}")
+        return
+
+    print(f"Found {len(files)} result files in {args.input_dir}")
+
+    # Evaluate all files
+    all_metrics = {}
+    for filepath in files:
+        print(f"  Loading: {os.path.basename(filepath)}")
+        model_name, metrics = evaluate_file(filepath)
+        all_metrics[model_name] = metrics
+
+    # Print aggregate tables
+    print_header("PEDAGOGICAL GROUNDING BENCHMARK - AGGREGATE RESULTS")
+
+    # Summary table
+    print_header("ACCURACY BY TASK", width=72)
+    print_summary_table(all_metrics)
+
+    # Lift table
+    print_header("LIFT OVER RANDOM BASELINE", width=72)
+    print_lift_table(all_metrics)
+
+    # Best model per task
+    print_header("BEST MODEL PER TASK", width=72)
+    print_best_model_per_task(all_metrics)
+
+    # Detailed stratum breakdown for comparison tasks
+    print_header("DIFFICULTY - ACCURACY BY STRATUM", width=70)
+    print_stratum_table(all_metrics, 'difficulty')
+
+    print_header("DISCRIMINATION - ACCURACY BY STRATUM", width=70)
+    print_stratum_table(all_metrics, 'discrimination')
+
+    # Individual task tables
+    for task in ['difficulty', 'discrimination', 'distractor_most', 'distractor_least']:
+        print_header(f"{task.upper()} - DETAILED", width=65)
+        print_accuracy_table(all_metrics, task)
+
+    # Save aggregate metrics if output specified
+    if args.output:
+        with open(args.output, 'w') as f:
+            json.dump(all_metrics, f, indent=2)
+        print(f"\nAggregate metrics saved to {args.output}")
+
+    print()
+
+
+if __name__ == "__main__":
+    main()

Results/pedagogical_grounding/distractor_analysis.py

@@ -0,0 +1,299 @@
+"""
+Distractor Analysis for Pedagogical Grounding
+
+Computes distractor effectiveness for Multiple Choice (select 1) questions
+with more than 2 choices. Identifies most/least common wrong answers.
+"""
+
+import argparse
+import os
+import json
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import Counter
+
+# Configuration
+DEFAULT_DATA_DIR = "foundationalktdataset"
+STUDENT_FILE = "Interactions.csv"
+PROBLEMS_FILE = "Problems.csv"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Analyze distractor effectiveness")
+    parser.add_argument(
+        "--data-dir", "-d",
+        type=str,
+        default=DEFAULT_DATA_DIR,
+        help=f"Directory containing input CSV files (default: {DEFAULT_DATA_DIR})"
+    )
+    parser.add_argument(
+        "--output-dir", "-o",
+        type=str,
+        default="pedagogical_grounding/output",
+        help="Directory to save output (default: pedagogical_grounding/output)"
+    )
+    parser.add_argument(
+        "--no-plots",
+        action="store_true",
+        help="Skip generating plots"
+    )
+    return parser.parse_args()
+
+
+def load_data(data_dir):
+    """Load student and problem data."""
+    print(f"Loading data from {data_dir}...")
+
+    student_df = pd.read_csv(os.path.join(data_dir, STUDENT_FILE))
+    problems_df = pd.read_csv(os.path.join(data_dir, PROBLEMS_FILE))
+
+    print(f"  Loaded {len(student_df):,} student interactions")
+    print(f"  Loaded {len(problems_df):,} problems")
+
+    return student_df, problems_df
+
+
+def get_answer_options(answer_string):
+    """Parse pipe-delimited answer options."""
+    if pd.isna(answer_string) or answer_string == '':
+        return []
+    return [opt.strip() for opt in answer_string.split('||') if opt.strip()]
+
+
+def get_correct_answers(correct_string):
+    """Parse pipe-delimited correct answers."""
+    if pd.isna(correct_string) or correct_string == '':
+        return []
+    return [ans.strip() for ans in correct_string.split('||') if ans.strip()]
+
+
+def normalize_answer(text):
+    """Normalize answer text for comparison."""
+    if pd.isna(text):
+        return ""
+    import re
+    # Remove HTML tags
+    text = re.sub(r'<[^>]+>', '', str(text))
+    # Normalize whitespace
+    text = ' '.join(text.split())
+    return text.strip().lower()
+
+
+def analyze_distractors(student_df, problems_df):
+    """Analyze distractor effectiveness for MC (select 1) with >2 choices."""
+    print("\n" + "=" * 60)
+    print(" DISTRACTOR ANALYSIS")
+    print("=" * 60)
+
+    # Filter to MC (select 1) problems
+    mc_problems = problems_df[problems_df['Problem Type'] == 'Multiple Choice (select 1)'].copy()
+
+    # Count choices
+    mc_problems['answer_options'] = mc_problems['Multiple Choice Options'].apply(get_answer_options)
+    mc_problems['n_choices'] = mc_problems['answer_options'].apply(len)
+
+    # Filter to >2 choices
+    mc_problems = mc_problems[mc_problems['n_choices'] > 2].copy()
+    print(f"\nMC (select 1) problems with >2 choices: {len(mc_problems)}")
+
+    # Get correct answers
+    mc_problems['correct_answers'] = mc_problems['Multiple Choice Answers'].apply(get_correct_answers)
+
+    # Filter student data to these problems
+    problem_ids = set(mc_problems['problem_id'])
+    mc_interactions = student_df[student_df['problem_id'].isin(problem_ids)].copy()
+    print(f"Student interactions for these problems: {len(mc_interactions):,}")
+
+    # Merge to get answer options
+    mc_interactions = mc_interactions.merge(
+        mc_problems[['problem_id', 'answer_options', 'correct_answers', 'n_choices']],
+        on='problem_id',
+        how='left'
+    )
+
+    # Analyze each problem
+    results = []
+
+    for problem_id in mc_problems['problem_id'].unique():
+        problem_data = mc_interactions[mc_interactions['problem_id'] == problem_id]
+
+        if len(problem_data) < 10:  # Skip problems with too few responses
+            continue
+
+        problem_info = mc_problems[mc_problems['problem_id'] == problem_id].iloc[0]
+        answer_options = problem_info['answer_options']
+        correct_answers = problem_info['Fill-in Answers']
+
+        # Normalize correct answers for comparison
+        correct_normalized = set(normalize_answer(a) for a in correct_answers)
+
+        # Count responses for each option
+        option_counts = Counter()
+        total_responses = 0
+
+        for _, row in problem_data.iterrows():
+            student_answer = row['answer_text']
+            if pd.isna(student_answer):
+                continue
+
+            # Normalize student answer
+            student_normalized = normalize_answer(student_answer)
+
+            # Match to options
+            for opt in answer_options:
+                opt_normalized = normalize_answer(opt)
+                if student_normalized == opt_normalized or student_normalized in opt_normalized or opt_normalized in student_normalized:
+                    option_counts[opt] += 1
+                    total_responses += 1
+                    break
+
+        if total_responses < 10:
+            continue
+
+        # Separate correct and incorrect options
+        distractors = {}
+        correct_count = 0
+
+        for opt in answer_options:
+            opt_normalized = normalize_answer(opt)
+            count = option_counts.get(opt, 0)
+
+            if opt_normalized in correct_normalized or any(normalize_answer(c) in opt_normalized or opt_normalized in normalize_answer(c) for c in correct_answers):
+                correct_count = count
+            else:
+                distractors[opt] = count
+
+        if not distractors:
+            continue
+
+        # Find most/least common distractor
+        sorted_distractors = sorted(distractors.items(), key=lambda x: x[1], reverse=True)
+        most_common = sorted_distractors[0]
+        least_common = sorted_distractors[-1]
+
+        # Compute frequencies
+        distractor_freqs = {opt: count / total_responses for opt, count in distractors.items()}
+
+        results.append({
+            'problem_id': int(problem_id),
+            'n_choices': int(problem_info['n_choices']),
+            'total_responses': int(total_responses),
+            'correct_count': int(correct_count),
+            'correct_rate': correct_count / total_responses,
+            'distractors': {opt: int(count) for opt, count in distractors.items()},
+            'distractor_frequencies': distractor_freqs,
+            'most_common_distractor': most_common[0],
+            'most_common_distractor_freq': most_common[1] / total_responses,
+            'least_common_distractor': least_common[0],
+            'least_common_distractor_freq': least_common[1] / total_responses,
+        })
+
+    print(f"Problems with sufficient data: {len(results)}")
+
+    return results
+
+
+def print_summary(results):
+    """Print summary statistics."""
+    print("\n--- Summary Statistics ---")
+
+    correct_rates = [r['correct_rate'] for r in results]
+    most_common_freqs = [r['most_common_distractor_freq'] for r in results]
+    least_common_freqs = [r['least_common_distractor_freq'] for r in results]
+
+    print(f"\nCorrect Answer Rate:")
+    print(f"  Mean: {np.mean(correct_rates):.1%}")
+    print(f"  Median: {np.median(correct_rates):.1%}")
+    print(f"  Min: {np.min(correct_rates):.1%}")
+    print(f"  Max: {np.max(correct_rates):.1%}")
+
+    print(f"\nMost Common Distractor Frequency:")
+    print(f"  Mean: {np.mean(most_common_freqs):.1%}")
+    print(f"  Median: {np.median(most_common_freqs):.1%}")
+
+    print(f"\nLeast Common Distractor Frequency:")
+    print(f"  Mean: {np.mean(least_common_freqs):.1%}")
+    print(f"  Median: {np.median(least_common_freqs):.1%}")
+
+    # Count problems where least common distractor is never chosen
+    never_chosen = sum(1 for r in results if r['least_common_distractor_freq'] == 0)
+    print(f"\nProblems with ineffective distractor (0 selections): {never_chosen} ({100*never_chosen/len(results):.1f}%)")
+
+
+def save_results(results, output_dir):
+    """Save results to JSON."""
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, 'distractor_stats.json')
+
+    with open(output_path, 'w') as f:
+        json.dump(results, f, indent=2)
+
+    print(f"\nSaved: {output_path}")
+
+
+def plot_results(results, output_dir):
+    """Generate plots."""
+    os.makedirs(output_dir, exist_ok=True)
+
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+    # Plot 1: Correct rate distribution
+    correct_rates = [r['correct_rate'] for r in results]
+    axes[0].hist(correct_rates, bins=20, edgecolor='black', alpha=0.7)
+    axes[0].set_xlabel('Correct Answer Rate')
+    axes[0].set_ylabel('Number of Problems')
+    axes[0].set_title('Distribution of Correct Answer Rates')
+    axes[0].axvline(np.mean(correct_rates), color='red', linestyle='--', label=f'Mean: {np.mean(correct_rates):.1%}')
+    axes[0].legend()
+
+    # Plot 2: Most common distractor frequency
+    most_common_freqs = [r['most_common_distractor_freq'] for r in results]
+    axes[1].hist(most_common_freqs, bins=20, edgecolor='black', alpha=0.7, color='orange')
+    axes[1].set_xlabel('Most Common Distractor Frequency')
+    axes[1].set_ylabel('Number of Problems')
+    axes[1].set_title('Distribution of Most Common Distractor')
+    axes[1].axvline(np.mean(most_common_freqs), color='red', linestyle='--', label=f'Mean: {np.mean(most_common_freqs):.1%}')
+    axes[1].legend()
+
+    # Plot 3: Least common distractor frequency
+    least_common_freqs = [r['least_common_distractor_freq'] for r in results]
+    axes[2].hist(least_common_freqs, bins=20, edgecolor='black', alpha=0.7, color='green')
+    axes[2].set_xlabel('Least Common Distractor Frequency')
+    axes[2].set_ylabel('Number of Problems')
+    axes[2].set_title('Distribution of Least Common Distractor')
+    axes[2].axvline(np.mean(least_common_freqs), color='red', linestyle='--', label=f'Mean: {np.mean(least_common_freqs):.1%}')
+    axes[2].legend()
+
+    plt.tight_layout()
+    plot_path = os.path.join(output_dir, 'distractor_analysis.png')
+    plt.savefig(plot_path, dpi=150)
+    plt.close()
+
+    print(f"Saved: {plot_path}")
+
+
+def main():
+    args = parse_args()
+
+    # Load data
+    student_df, problems_df = load_data(args.data_dir)
+
+    # Analyze distractors
+    results = analyze_distractors(student_df, problems_df)
+
+    # Print summary
+    print_summary(results)
+
+    # Save results
+    save_results(results, args.output_dir)
+
+    # Plot
+    if not args.no_plots:
+        plot_results(results, args.output_dir)
+
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()

Results/pedagogical_grounding/evaluate_pedagogical.py

@@ -0,0 +1,285 @@
+"""
+Evaluation script for Pedagogical Grounding LLM Benchmark.
+
+Computes accuracy metrics for:
+1. Difficulty comparison task
+2. Discrimination comparison task
+3. Most common distractor prediction
+4. Least common distractor prediction
+
+Usage:
+    python evaluate_pedagogical.py --input results.jsonl
+    python evaluate_pedagogical.py --input results.jsonl --output metrics.json
+"""
+
+import argparse
+import json
+from collections import defaultdict
+from typing import Dict, List, Optional
+
+
+def load_results(jsonl_path: str) -> List[Dict]:
+    """Load results from JSONL file."""
+    results = []
+    with open(jsonl_path, 'r') as f:
+        for line in f:
+            if line.strip():
+                results.append(json.loads(line))
+    return results
+
+
+def evaluate_comparison_task(results: List[Dict], task_name: str) -> Dict:
+    """Evaluate a comparison task (difficulty or discrimination)."""
+    task_results = [r for r in results if r.get('task') == task_name]
+
+    if not task_results:
+        return {'error': f'No results found for task: {task_name}'}
+
+    total = len(task_results)
+    correct = sum(1 for r in task_results if r.get('is_correct', False))
+    accuracy = correct / total if total > 0 else 0
+
+    # Breakdown by stratum
+    stratum_stats = defaultdict(lambda: {'correct': 0, 'total': 0})
+    for r in task_results:
+        stratum = r.get('stratum', 'unknown')
+        stratum_stats[stratum]['total'] += 1
+        if r.get('is_correct', False):
+            stratum_stats[stratum]['correct'] += 1
+
+    stratum_accuracy = {}
+    for stratum, stats in stratum_stats.items():
+        if stats['total'] > 0:
+            stratum_accuracy[stratum] = {
+                'accuracy': stats['correct'] / stats['total'],
+                'correct': stats['correct'],
+                'total': stats['total']
+            }
+
+    # Breakdown by difficulty difference bins
+    diff_bins = [
+        ('very_small', 0, 0.2),
+        ('small', 0.2, 0.5),
+        ('medium', 0.5, 1.0),
+        ('large', 1.0, float('inf'))
+    ]
+
+    diff_stats = defaultdict(lambda: {'correct': 0, 'total': 0})
+    for r in task_results:
+        diff = r.get('difference', 0)
+        for bin_name, low, high in diff_bins:
+            if low <= diff < high:
+                diff_stats[bin_name]['total'] += 1
+                if r.get('is_correct', False):
+                    diff_stats[bin_name]['correct'] += 1
+                break
+
+    diff_accuracy = {}
+    for bin_name, stats in diff_stats.items():
+        if stats['total'] > 0:
+            diff_accuracy[bin_name] = {
+                'accuracy': stats['correct'] / stats['total'],
+                'correct': stats['correct'],
+                'total': stats['total']
+            }
+
+    return {
+        'task': task_name,
+        'total': total,
+        'correct': correct,
+        'accuracy': accuracy,
+        'baseline_random': 0.5,  # Random guess for binary choice
+        'lift_over_random': accuracy - 0.5,
+        'by_stratum': dict(stratum_accuracy),
+        'by_difference': dict(diff_accuracy)
+    }
+
+
+def evaluate_distractor_task(results: List[Dict], task_name: str) -> Dict:
+    """Evaluate a distractor task (most or least common)."""
+    task_results = [r for r in results if r.get('task') == task_name]
+
+    if not task_results:
+        return {'error': f'No results found for task: {task_name}'}
+
+    total = len(task_results)
+    correct = sum(1 for r in task_results if r.get('is_correct', False))
+    accuracy = correct / total if total > 0 else 0
+
+    # Breakdown by number of choices
+    choices_stats = defaultdict(lambda: {'correct': 0, 'total': 0})
+    for r in task_results:
+        n_choices = r.get('n_choices', 0)
+        # Number of distractors = n_choices - 1 (excluding correct answer)
+        n_distractors = n_choices - 1 if n_choices > 1 else 1
+        choices_stats[n_distractors]['total'] += 1
+        if r.get('is_correct', False):
+            choices_stats[n_distractors]['correct'] += 1
+
+    choices_accuracy = {}
+    baseline_by_choices = {}
+    for n_distractors, stats in sorted(choices_stats.items()):
+        if stats['total'] > 0:
+            acc = stats['correct'] / stats['total']
+            baseline = 1.0 / n_distractors if n_distractors > 0 else 0
+            choices_accuracy[f'{n_distractors}_distractors'] = {
+                'accuracy': acc,
+                'correct': stats['correct'],
+                'total': stats['total'],
+                'baseline_random': baseline,
+                'lift_over_random': acc - baseline
+            }
+            baseline_by_choices[n_distractors] = baseline
+
+    # Compute weighted average baseline
+    total_weighted_baseline = 0
+    for r in task_results:
+        n_choices = r.get('n_choices', 0)
+        n_distractors = n_choices - 1 if n_choices > 1 else 1
+        if n_distractors > 0:
+            total_weighted_baseline += 1.0 / n_distractors
+    avg_baseline = total_weighted_baseline / total if total > 0 else 0
+
+    # Breakdown by ground truth frequency
+    freq_bins = [
+        ('very_rare', 0, 0.05),
+        ('rare', 0.05, 0.10),
+        ('moderate', 0.10, 0.20),
+        ('common', 0.20, 0.30),
+        ('very_common', 0.30, 1.0)
+    ]
+
+    freq_stats = defaultdict(lambda: {'correct': 0, 'total': 0})
+    for r in task_results:
+        freq = r.get('ground_truth_freq', 0)
+        for bin_name, low, high in freq_bins:
+            if low <= freq < high:
+                freq_stats[bin_name]['total'] += 1
+                if r.get('is_correct', False):
+                    freq_stats[bin_name]['correct'] += 1
+                break
+
+    freq_accuracy = {}
+    for bin_name, stats in freq_stats.items():
+        if stats['total'] > 0:
+            freq_accuracy[bin_name] = {
+                'accuracy': stats['correct'] / stats['total'],
+                'correct': stats['correct'],
+                'total': stats['total']
+            }
+
+    return {
+        'task': task_name,
+        'total': total,
+        'correct': correct,
+        'accuracy': accuracy,
+        'baseline_random_avg': avg_baseline,
+        'lift_over_random': accuracy - avg_baseline,
+        'by_num_distractors': dict(choices_accuracy),
+        'by_ground_truth_freq': dict(freq_accuracy)
+    }
+
+
+def print_comparison_results(metrics: Dict) -> None:
+    """Print comparison task results."""
+    print(f"\n{'='*60}")
+    print(f"Task: {metrics['task'].upper()}")
+    print(f"{'='*60}")
+
+    print(f"\nOverall Accuracy: {metrics['accuracy']:.1%} ({metrics['correct']}/{metrics['total']})")
+    print(f"Random Baseline:  {metrics['baseline_random']:.1%}")
+    print(f"Lift over Random: {metrics['lift_over_random']:+.1%}")
+
+    if metrics.get('by_stratum'):
+        print(f"\nBy Sampling Stratum:")
+        for stratum, stats in sorted(metrics['by_stratum'].items()):
+            print(f"  {stratum:12}: {stats['accuracy']:.1%} ({stats['correct']}/{stats['total']})")
+
+    if metrics.get('by_difference'):
+        print(f"\nBy Value Difference:")
+        for bin_name, stats in metrics['by_difference'].items():
+            print(f"  {bin_name:12}: {stats['accuracy']:.1%} ({stats['correct']}/{stats['total']})")
+
+
+def print_distractor_results(metrics: Dict) -> None:
+    """Print distractor task results."""
+    print(f"\n{'='*60}")
+    print(f"Task: {metrics['task'].upper()}")
+    print(f"{'='*60}")
+
+    print(f"\nOverall Accuracy: {metrics['accuracy']:.1%} ({metrics['correct']}/{metrics['total']})")
+    print(f"Random Baseline:  {metrics['baseline_random_avg']:.1%} (weighted avg)")
+    print(f"Lift over Random: {metrics['lift_over_random']:+.1%}")
+
+    if metrics.get('by_num_distractors'):
+        print(f"\nBy Number of Distractors:")
+        for key, stats in sorted(metrics['by_num_distractors'].items()):
+            print(f"  {key:15}: {stats['accuracy']:.1%} ({stats['correct']}/{stats['total']}) "
+                  f"[baseline: {stats['baseline_random']:.1%}, lift: {stats['lift_over_random']:+.1%}]")
+
+    if metrics.get('by_ground_truth_freq'):
+        print(f"\nBy Ground Truth Frequency:")
+        for bin_name, stats in metrics['by_ground_truth_freq'].items():
+            print(f"  {bin_name:12}: {stats['accuracy']:.1%} ({stats['correct']}/{stats['total']})")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Evaluate Pedagogical Grounding Benchmark Results"
+    )
+    parser.add_argument(
+        "--input", "-i",
+        type=str,
+        required=True,
+        help="Input JSONL file with predictions"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        type=str,
+        default=None,
+        help="Output JSON file for metrics (optional)"
+    )
+    args = parser.parse_args()
+
+    print(f"Loading results from {args.input}...")
+    results = load_results(args.input)
+    print(f"Loaded {len(results)} predictions")
+
+    # Identify tasks in results
+    tasks = set(r.get('task') for r in results if r.get('task'))
+    print(f"Tasks found: {tasks}")
+
+    all_metrics = {}
+
+    # Evaluate each task
+    for task in sorted(tasks):
+        if task in ['difficulty', 'discrimination']:
+            metrics = evaluate_comparison_task(results, task)
+            print_comparison_results(metrics)
+        elif task in ['distractor_most', 'distractor_least']:
+            metrics = evaluate_distractor_task(results, task)
+            print_distractor_results(metrics)
+        else:
+            print(f"Unknown task: {task}")
+            continue
+
+        all_metrics[task] = metrics
+
+    # Summary
+    print(f"\n{'='*60}")
+    print("SUMMARY")
+    print(f"{'='*60}")
+    for task, metrics in all_metrics.items():
+        if 'error' not in metrics:
+            print(f"{task:20}: {metrics['accuracy']:.1%} accuracy "
+                  f"({metrics['lift_over_random']:+.1%} vs random)")
+
+    # Save metrics if output specified
+    if args.output:
+        with open(args.output, 'w') as f:
+            json.dump(all_metrics, f, indent=2)
+        print(f"\nMetrics saved to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

Results/pedagogical_grounding/gptoss120b_pedagogical.py

@@ -0,0 +1,57 @@
+"""
+Pedagogical Grounding benchmark with GPT-OSS-120B model.
+
+Usage:
+    # Run difficulty comparison task
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120b_pedagogical.py \
+        --task difficulty \
+        --data-dir . \
+        --num-gpus 4 \
+        --num-samples 1000 \
+        --sampling-mode stratified \
+        --cache-dir /data1/
+
+    # Run discrimination comparison task
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120b_pedagogical.py \
+        --task discrimination \
+        --data-dir . \
+        --num-gpus 4 \
+        --num-samples 1000
+
+    # Run most common distractor task
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120b_pedagogical.py \
+        --task distractor_most \
+        --data-dir . \
+        --num-gpus 4
+
+    # Run least common distractor task
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120b_pedagogical.py \
+        --task distractor_least \
+        --data-dir . \
+        --num-gpus 4
+
+    # Run all tasks
+    CUDA_VISIBLE_DEVICES=0,1,2,3 python gptoss120b_pedagogical.py \
+        --task all \
+        --data-dir . \
+        --num-gpus 4 \
+        --num-samples 500
+"""
+
+from pedagogical_inference_base import run_inference
+
+MODEL_CONFIG = {
+    "model_id": "openai/gpt-oss-120b",
+    "gen_configs": {
+        "temperature": 0.7,
+        "top_p": 0.95,
+        "top_k": 20,
+        "max_tokens": 1024,  # Shorter responses expected for this task
+        "repetition_penalty": 1.0,
+    },
+    "output_prefix": "gptoss120b",
+    "system_prompt_prefix": "Reasoning: medium\n\n",
+}
+
+if __name__ == "__main__":
+    run_inference(MODEL_CONFIG)