curation/scripts/task_difficulty.py

"""Conservative task screening for a strong Qwen3.6-27B target.

These labels are source/structure priors, never measured model performance.
`core_candidate` identifies evidence worth testing; `uncalibrated` may still be
basic. Prompt/reference length, presence of tests/tools, and source prestige do
not establish difficulty. This module does not execute source programs or SQL.
"""
from __future__ import annotations

from collections import Counter
import json
from pathlib import Path
import re

TARGET_MODEL = 'Qwen3.6-27B'
POLICY_VERSION = 'qwen3.6-27b-structural-v1'
TIERS = ('foundational', 'core_candidate', 'uncalibrated')
DIFFICULTY_FIELDS = (
    'difficulty_tier', 'difficulty_evidence', 'difficulty_tier_confidence',
    'difficulty_target_model', 'difficulty_validation',
)

ARITHMETIC = re.compile(r"^(?:(?:what(?: is|'s)|calculate|compute|evaluate|solve|please (?:calculate|compute|evaluate))\s+)?([+-]?\d{1,3})\s*([+*/×÷-])\s*([+-]?\d{1,3})(?:\s*=)?\s*[?.!]*$", re.I)
CAPITAL = re.compile(r"^what(?: is|'s) the capital(?: city)? of (?:the )?(?:france|germany|italy|spain|portugal|japan|china|india|canada|australia|brazil|united states(?: of america)?|usa|u\.s\.a\.|united kingdom|uk|russia|egypt|south korea)\s*[?.!]*$", re.I)
GREETING = re.compile(r"^(?:hi|hello|hey|good morning|good afternoon|good evening)(?:[!., ]+(?:there|how are you))?\s*[?.!]*$", re.I)
UNITS = re.compile(r"^how many (seconds|minutes|hours|days|months|centimeters|millimeters|meters|grams) (?:are (?:there )?)?in (?:a|an|one|1) (minute|hour|day|week|year|meter|centimeter|kilometer|kilogram)\s*[?.!]*$", re.I)
UNIT_RELATIONS = {('seconds', 'minute'), ('minutes', 'hour'), ('hours', 'day'), ('days', 'week'), ('months', 'year'), ('centimeters', 'meter'), ('millimeters', 'centimeter'), ('millimeters', 'meter'), ('meters', 'kilometer'), ('grams', 'kilogram')}
LINEAR = re.compile(r'^(?:solve(?: for (?P<variable>[a-z]))?|find (?P<find_variable>[a-z]))\s*[:;,]?\s*(?P<equation>[0-9a-z+*/=(). \t-]+)[?.!]*$', re.I)
SQL_LITERAL_OR_COMMENT = re.compile(r"'(?:''|[^'])*'|\"(?:\"\"|[^\"])*\"|`[^`]*`|--[^\n]*|/\*.*?\*/", re.S)
COMPETITION_BUCKETS = {'olympiads', 'olympiads_ref', 'cn_contest', 'amc_aime', 'inequalities', 'number_theory'}
NUMINA_INVALID = {'source_problem_is_valid_not_yes', 'source_solution_is_valid_not_yes', 'missing_prompt', 'prompt_external_image_dependency', 'reference_external_image_dependency', 'prompt_language_needs_review'}


def _object(value):
    if isinstance(value, dict):
        return value
    if isinstance(value, str) and value:
        try:
            parsed = json.loads(value)
        except (ValueError, TypeError):
            return {}
        return parsed if isinstance(parsed, dict) else {}
    return {}


def _result(tier, evidence, confidence='structural_heuristic'):
    return {
        'difficulty_tier': tier,
        'difficulty_evidence': list(evidence),
        'difficulty_tier_confidence': confidence,
        'difficulty_target_model': TARGET_MODEL,
        'difficulty_validation': 'heuristic_not_model_measured',
    }


def elementary_signal(prompt, context=''):
    """Match whole unconstrained tasks, never substrings inside harder tasks."""
    if context and str(context).strip() not in {'', '[]'}:
        return None
    text = str(prompt or '').strip().replace('’', "'")
    # A surrounding mathematical delimiter does not create an extra task.
    text = text.replace('$', '')
    m = ARITHMETIC.fullmatch(text)
    if m and not (m[2] in {'/', '÷'} and int(m[3]) == 0):
        return 'exact_single_small_integer_arithmetic'
    if CAPITAL.fullmatch(text):
        return 'direct_common_country_capital_lookup'
    if GREETING.fullmatch(text):
        return 'greeting_only'
    m = UNITS.fullmatch(text)
    if m and (m[1].lower(), m[2].lower()) in UNIT_RELATIONS:
        return 'fixed_unit_conversion'
    m = LINEAR.fullmatch(text)
    if m:
        equation = m['equation'].lower().strip().rstrip('.')
        letters = re.findall(r'[a-z]', equation)
        variable = (m['variable'] or m['find_variable'] or (letters[0] if letters else '')).lower()
        numbers = re.findall(r'\d+(?:\.\d+)?', equation)
        term = r'(?:[+-]?\d{1,3}\s*\*?\s*)?' + re.escape(variable) + r'(?:\s*[+-]\s*\d{1,3})?'
        constant = r'[+-]?\d{1,3}'
        if (variable and letters == [variable] and equation.count('=') == 1
                and (re.fullmatch(term + r'\s*=\s*' + constant, equation)
                     or re.fullmatch(constant + r'\s*=\s*' + term, equation))):
            return 'exact_one_variable_linear_equation'
    return None


def _sql_difficulty(row, meta):
    label = str(meta.get('sql_complexity') or row.get('source_difficulty') or '')
    sql = SQL_LITERAL_OR_COMMENT.sub(' ', str(row.get('reference_solution') or ''))
    tokens = re.findall(r'[A-Za-z_]+', sql.upper())
    counts = Counter(tokens)
    statements = sum(bool(s.strip()) for s in sql.split(';'))
    selects, joins = counts['SELECT'], counts['JOIN']
    advanced = sorted(set(tokens) & {'WITH', 'OVER', 'UNION', 'INTERSECT', 'EXCEPT', 'RECURSIVE'})
    features = f'sql_structure:selects={selects};joins={joins};statements={statements};advanced={",".join(advanced) or "none"}'
    evidence = [f'source_sql_complexity:{label or "missing"}', features]
    if (label in {'basic SQL', 'aggregation', 'single join'} and tokens
            and selects <= 1 and joins <= 1 and statements == 1 and not advanced):
        return _result('foundational', evidence + ['single_statement_basic_query_or_update_without_advanced_query_structure'])
    # An isolated SQL feature is not sufficient to call a task challenging.
    aggregate = bool(set(tokens) & {'GROUP', 'HAVING', 'COUNT', 'SUM', 'AVG'})
    combined = (joins >= 2 and aggregate) or (selects >= 2 and counts['OVER']) or (counts['WITH'] and counts['OVER']) or counts['RECURSIVE']
    if combined:
        return _result('core_candidate', evidence + ['combined_relational_operations_require_calibration'])
    return _result('uncalibrated', evidence + ['source_sql_category_alone_does_not_establish_model_difficulty'], 'uncalibrated')


def _numina_difficulty(row, meta):
    bucket, kind = str(meta.get('source') or ''), str(meta.get('question_type') or '')
    evidence = [f'numina_source_bucket:{bucket or "missing"}', f'source_question_type:{kind or "missing"}']
    if set(row.get('quality_flags') or []) & NUMINA_INVALID:
        return _result('uncalibrated', evidence + ['source_validity_or_required_context_issue_prevents_difficulty_inference'], 'uncalibrated')
    prompt = str(row.get('prompt') or '')
    lower = prompt.lower()
    if bucket in COMPETITION_BUCKETS:
        proof = bool(re.search(r'\b(?:prove|show that|demonstrate that)\b', lower))
        find_all = bool(re.search(r'\b(?:find|determine) all\b', lower))
        functional = find_all and bool(re.search(r'\bfunctions?\b', lower)) and len(re.findall(r'\bf\s*\(', lower)) >= 2
        math_regions = ' '.join(re.findall(r'\$([^$]+)\$', prompt))
        variables = set(re.findall(r'\b[a-z]\b', math_regions.lower()))
        integer_classification = (find_all and len(variables) >= 3
            and bool(re.search(r'\b(?:positive integers?|integers?|prime numbers?)\b', lower))
            and 'such that' in lower and bool(re.search(r'\^\s*(?:\{?[a-z]|\{?[3-9])', lower)))
        multivariable_inequality = (proof and len(variables) >= 3
            and bool(re.search(r'\bpositive (?:real )?(?:numbers?|variables?)\b', lower))
            and bool(re.search(r'\\(?:le|ge|leq|geq)|inequalit', lower))
            and bool(re.search(r'\^\s*\{?[2-9]', lower)))
        geometry_structures = [term for term in ('cyclic', 'tangent', 'circumcircle', 'orthocenter', 'incircle', 'concurrent') if term in lower]
        geometry_proof = proof and len(geometry_structures) >= 2
        structures = []
        if functional:
            structures.append('universal_function_classification_with_multiple_function_applications')
        if integer_classification:
            structures.append('integer_classification_with_symbolic_or_higher_power_constraints')
        if multivariable_inequality:
            structures.append('proof_with_multivariable_nonlinear_inequality_constraints')
        if geometry_proof:
            structures.append('proof_combining_geometry_structures:' + ','.join(geometry_structures))
        if structures:
            return _result('core_candidate', evidence + structures + ['contest_source_and_structure_joint_prior_not_measured_difficulty'])
    return _result('uncalibrated', evidence + ['source_bucket_and_answer_or_solution_length_do_not_establish_difficulty'], 'uncalibrated')


def _schema_features(schema):
    """Read schema constraints as data; no validator/source code is executed."""
    schema = _object(schema)
    props = schema.get('properties', {})
    primitive = {'string', 'number', 'integer', 'boolean', 'null'}
    complex_keys = {'properties', 'items', '$ref', 'oneOf', 'anyOf', 'allOf', 'if', 'then', 'else', 'pattern', 'dependentSchemas', 'dependentRequired'}
    flat = schema.get('type') == 'object' and isinstance(props, dict) and 1 <= len(props) <= 6
    for value in props.values() if isinstance(props, dict) else []:
        if not isinstance(value, dict):
            flat = False
            continue
        kinds = value.get('type', [])
        kinds = [kinds] if isinstance(kinds, str) else kinds
        flat = flat and isinstance(kinds, list) and bool(kinds) and all(isinstance(k, str) for k in kinds) and set(kinds) <= primitive and not set(value) & complex_keys
    depth, branches = 0, 0
    stack = [(schema, 0)]
    seen = 0
    while stack:
        value, level = stack.pop()
        seen += 1
        if seen > 20000:
            return False, depth, branches
        if isinstance(value, dict):
            next_level = level + int(value.get('type') == 'object' or 'properties' in value)
            depth = max(depth, next_level)
            branches += sum(key in value for key in ('oneOf', 'anyOf', 'allOf', 'if', 'dependentSchemas'))
            stack.extend((v, next_level) for v in value.values() if isinstance(v, (list, dict)))
        elif isinstance(value, list):
            stack.extend((v, level) for v in value if isinstance(v, (list, dict)))
    return bool(flat) and not branches and not set(schema) & complex_keys.difference({'properties'}), depth, branches


def _structured_difficulty(row, meta):
    kind = str(meta.get('problem_type') or '')
    config = str(meta.get('config') or '')
    verifier = _object(row.get('verifier_json'))
    flat, depth, branches = _schema_features(verifier.get('schema_str'))
    evidence = [f'structured_config:{config or "missing"}', f'source_problem_type:{kind or "missing"}', f'schema_structure:object_depth={depth};constraint_branches={branches}']
    if kind == 'schema_only' and flat:
        return _result('foundational', evidence + ['placeholder_generation_for_flat_schema_with_at_most_six_primitive_fields'])
    try:
        distractors = int(meta.get('num_distractors') or 0)
    except (ValueError, TypeError):
        distractors = 0
    if config == 'tool_calling_extraction' and distractors >= 5 and (depth >= 3 or branches):
        return _result('core_candidate', evidence + [f'tool_schema_selection_distractors:{distractors}', 'tool_selection_combined_with_nested_or_branching_schema_requires_calibration'])
    return _result('uncalibrated', evidence + ['schema_size_format_or_conversation_length_alone_does_not_establish_model_difficulty'], 'uncalibrated')


def annotate_difficulty(row):
    """Return additive difficulty fields without modifying the normalized row."""
    source = str(row.get('source') or '')
    group_sources = row.get('group_sources') or []
    if isinstance(group_sources, str):
        try:
            group_sources = json.loads(group_sources)
        except ValueError:
            group_sources = []
    sources = {source} | {s for s in group_sources if isinstance(s, str)} if isinstance(group_sources, list) else {source}
    meta = _object(row.get('source_metadata_json'))
    if 'gsm8k' in sources:
        return _result('foundational', ['gsm8k_grade_school_arithmetic_source_prior', 'individual_exceptions_require_model_calibration'], 'source_prior')
    if 'mbpp' in sources:
        return _result('foundational', ['mbpp_entry_level_python_source_prior', 'individual_exceptions_require_model_calibration'], 'source_prior')
    if source == 'gretel_sql':
        return _sql_difficulty(row, meta)
    elementary = elementary_signal(row.get('prompt'), row.get('context'))
    if elementary:
        return _result('foundational', [elementary, 'whole_prompt_with_no_extra_context_constraints'])
    if source == 'numinamath':
        return _numina_difficulty(row, meta)
    if source == 'nemotron_structured':
        return _structured_difficulty(row, meta)
    source_label = str(row.get('source_difficulty') or '').strip()
    estimated = str(row.get('estimated_difficulty') or '').strip().lower()
    if source_label.lower() in {'easy', 'introductory', 'beginner', 'entry-level'} or estimated == 'introductory':
        return _result('foundational', [f'source_difficulty_label:{source_label or "missing"}', f'existing_difficulty_estimate:{estimated or "missing"}', 'source_or_adapter_prior_only_not_measured_qwen_performance'], 'source_prior')
    evidence = ['no_validated_difficulty_measurement_for_target_model']
    if source_label:
        evidence.append('source_difficulty_metadata:' + source_label)
    if source == 'nemotron_science':
        evidence.append('science_topic_reference_length_and_tool_access_do_not_establish_difficulty')
    else:
        evidence.append('source_family_medium_hard_labels_and_input_length_are_not_sufficient')
    return _result('uncalibrated', evidence, 'uncalibrated')


def main():
    import argparse
    import pyarrow.parquet as pq
    from full_curation_common import BASE, STAGING
    from assemble_task_dataset import classification
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--sources', nargs='+')
    parser.add_argument('--audit-output', type=Path, default=BASE / 'audit_difficulty_sources.json')
    args = parser.parse_args()
    folders = [STAGING / s for s in args.sources] if args.sources else sorted(p for p in STAGING.iterdir() if (p / 'manifest.json').exists())
    results = {}
    for folder in folders:
        counts, eligible, evidence_counts = Counter(), Counter(), Counter()
        for path in sorted(folder.glob('*.parquet')):
            for batch in pq.ParquetFile(path).iter_batches(batch_size=512):
                for row in batch.to_pylist():
                    annotation = annotate_difficulty(row)
                    tier = annotation['difficulty_tier']
                    counts[tier] += 1
                    if not classification(row):
                        eligible[tier] += 1
                    if tier != 'uncalibrated':
                        evidence_counts.update(annotation['difficulty_evidence'])
        results[folder.name] = {'annotations': dict(counts), 'eligible_annotations': dict(eligible), 'tier_evidence_counts': dict(evidence_counts)}
        print(json.dumps({'source': folder.name, **results[folder.name]}), flush=True)
    report = {'policy_version': POLICY_VERSION, 'target_model': TARGET_MODEL, 'validation': 'heuristic_not_model_measured',
              'unit': 'source annotations; final task groups must be counted after deduplication', 'sources': results,
              'limits': ['Foundational labels are transparent screening priors, not measured Qwen pass rates.',
                         'Uncalibrated tasks may still be easy; their inclusion does not certify a challenging core.',
                         'Core candidates combine explicit structural demands and source context; they require empirical testing.',
                         'No task length threshold, source prestige alone, test existence, or tool access determines difficulty.']}
    args.audit_output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')


if __name__ == '__main__':
    main()