quixi_math_datagen.py

#!/usr/bin/env python3
# -----------------------------------------------------------
# quixi_math_datagen.py
# Main script to generate the dataset using individual generator classes.
# -----------------------------------------------------------
import json
import random
import argparse
import sys
import os

from curriculum import GRADE_LEVELS, stamp_metadata
from datagen_common import (group_into_skills, instance_label, parse_weights,
                            run_build, validate_structure, write_jsonl)
from helpers import DELIM

# Import Generator Classes (from generators subdirectory)
from generators.long_division_generator import LongDivisionGenerator
from generators.decimal_mult_generator import DecimalMultGenerator
from generators.decimal_add_sub_generator import DecimalAddSubGenerator
from generators.decimal_div_generator import DecimalDivGenerator
from generators.fraction_op_generator import FractionOpGenerator
from generators.linear_simple_generator import LinearSimpleGenerator
from generators.quadratic_generator import QuadraticGenerator
from generators.simplify_expression_generator import SimplifyExpressionGenerator
from generators.evaluate_expression_generator import EvaluateExpressionGenerator
from generators.linear_complex_generator import LinearComplexGenerator
from generators.pythag_hyp_generator import PythagHypGenerator
from generators.abacus_addition_generator import AbacusAdditionGenerator
from generators.proportional_relationship_generator import ProportionalRelationshipGenerator
from generators.percent_problem_generator import PercentProblemGenerator
from generators.multi_digit_addition_generator import MultiDigitAdditionGenerator
from generators.multi_digit_subtraction_generator import MultiDigitSubtractionGenerator
from generators.multi_digit_multiplication_generator import MultiDigitMultiplicationGenerator
from generators.mixed_number_operation_generator import MixedNumberOperationGenerator
from generators.mixed_number_operations_random import MixedNumberOperationsRandom
from generators.fraction_comparison_generator import FractionComparisonGenerator
from generators.fraction_decimal_percent_converter import FractionDecimalPercentConverter
from generators.factors_generator import FactorsGenerator
from generators.prime_factorization_generator import PrimeFactorizationGenerator
from generators.gcf_generator import GCFGenerator
from generators.lcm_generator import LCMGenerator
from generators.order_of_operations_generator import OrderOfOperationsGenerator
from generators.geometry_area_perimeter_generator import GeometryAreaPerimeterGenerator
from generators.polygon_perimeter_generator import PolygonPerimeterGenerator
from generators.volume_rect_prism_generator import VolumeRectPrismGenerator
from generators.place_value_rounding_generator import PlaceValueRoundingGenerator
from generators.divisibility_classification_generator import DivisibilityClassificationGenerator
from generators.unit_conversion_generator import UnitConversionGenerator
from generators.multi_step_unit_conversion_generator import MultiStepUnitConversionGenerator
from generators.rate_conversion_generator import RateConversionGenerator
from generators.temperature_conversion_generator import TemperatureConversionGenerator
from generators.dimensional_analysis_generator import DimensionalAnalysisGenerator
from generators.percent_word_problem_generator import PercentWordProblemGenerator
from generators.repeating_decimal_generator import RepeatingDecimalGenerator
from generators.proportion_word_problem_generator import ProportionWordProblemGenerator
from generators.simple_stats_generator import SimpleStatsGenerator
from generators.number_comparison_generator import NumberComparisonGenerator
from generators.simple_probability_generator import SimpleProbabilityGenerator
from generators.likelihood_language_generator import LikelihoodLanguageGenerator
from generators.sample_space_list_generator import SampleSpaceListGenerator
from generators.complement_probability_generator import ComplementProbabilityGenerator
from generators.experimental_probability_generator import ExperimentalProbabilityGenerator
from generators.fundamental_counting_principle_generator import FundamentalCountingPrincipleGenerator
from generators.odds_probability_generator import OddsProbabilityGenerator
from generators.probability_axioms_finite_generator import ProbabilityAxiomsFiniteGenerator
from generators.tree_diagram_probability_generator import TreeDiagramProbabilityGenerator
from generators.random_digit_simulation_generator import RandomDigitSimulationGenerator
from generators.two_way_table_probability_generator import TwoWayTableProbabilityGenerator
from generators.venn_probability_generator import VennProbabilityGenerator
from generators.counting_to_probability_generator import CountingToProbabilityGenerator
from generators.probability_measure_generator import ProbabilityMeasureGenerator
from generators.reliability_system_generator import ReliabilitySystemGenerator
from generators.independence_check_generator import IndependenceCheckGenerator
from generators.law_of_total_probability_generator import LawOfTotalProbabilityGenerator
from generators.discrete_uniform_bernoulli_generator import DiscreteUniformBernoulliGenerator
from generators.pmf_cdf_quantile_generator import PmfCdfQuantileGenerator
from generators.expectation_of_function_generator import ExpectationOfFunctionGenerator
from generators.bayes_multiple_hypotheses_generator import BayesMultipleHypothesesGenerator
from generators.hypergeometric_generator import HypergeometricGenerator
from generators.classic_probability_puzzles_generator import ClassicProbabilityPuzzlesGenerator
from generators.normal_approx_binomial_generator import NormalApproxBinomialGenerator
from generators.linearity_of_expectation_generator import LinearityOfExpectationGenerator
from generators.covariance_algebra_generator import CovarianceAlgebraGenerator
from generators.conditional_expectation_generator import ConditionalExpectationGenerator
from generators.distribution_of_sum_generator import DistributionOfSumGenerator
from generators.probability_inequality_generator import ProbabilityInequalityGenerator
from generators.pgf_generator import PGFGenerator
from generators.negative_binomial_generator import NegativeBinomialGenerator
from generators.multinomial_probability_generator import MultinomialProbabilityGenerator
from generators.poisson_process_generator import PoissonProcessGenerator
from generators.random_walk_generator import RandomWalkGenerator
from generators.multi_state_markov_generator import MultiStateMarkovGenerator
from generators.monte_carlo_arithmetic_generator import MonteCarloArithmeticGenerator
from generators.expected_value_classics_generator import ExpectedValueClassicsGenerator
from generators.finite_sigma_algebra_generator import FiniteSigmaAlgebraGenerator
from generators.ballot_reflection_generator import BallotReflectionGenerator
from generators.polya_urn_generator import PolyaUrnGenerator
from generators.markov_state_classification_generator import MarkovStateClassificationGenerator
from generators.martingale_check_generator import MartingaleCheckGenerator
from generators.probability_critic_generator import ProbabilityCriticGenerator
from generators.tally_frequency_generator import TallyFrequencyGenerator
from generators.dot_plot_generator import DotPlotGenerator
from generators.fraction_line_plot_generator import FractionLinePlotGenerator
from generators.stem_and_leaf_generator import StemAndLeafGenerator
from generators.population_sample_generator import PopulationSampleGenerator
from generators.box_plot_generator import BoxPlotGenerator
from generators.histogram_construct_generator import HistogramConstructGenerator
from generators.weighted_mean_generator import WeightedMeanGenerator
from generators.mean_adjustment_generator import MeanAdjustmentGenerator
from generators.alternative_means_generator import AlternativeMeansGenerator
from generators.grouped_data_generator import GroupedDataGenerator
from generators.percentile_generator import PercentileGenerator
from generators.linear_transform_effect_generator import LinearTransformEffectGenerator
from generators.scatter_plot_describe_generator import ScatterPlotDescribeGenerator
from generators.two_way_table_generator import TwoWayTableGenerator
from generators.covariance_correlation_generator import CovarianceCorrelationGenerator
from generators.empirical_rule_generator import EmpiricalRuleGenerator
from generators.inverse_normal_generator import InverseNormalGenerator
from generators.sampling_distribution_enum_generator import SamplingDistributionEnumGenerator
from generators.clt_probability_generator import CLTProbabilityGenerator
from generators.p_value_generator import PValueGenerator
from generators.inference_setup_generator import InferenceSetupGenerator
from generators.t_interval_generator import TIntervalGenerator
from generators.graph_interpret_generator import GraphInterpretGenerator

# Middle School (6-8) Generators
from generators.integer_operations_generator import IntegerOperationsGenerator
from generators.unit_rate_generator import UnitRateGenerator, UnitRateFromTableGenerator
from generators.ratio_table_generator import RatioTableGenerator
from generators.tip_bill_split_generator import TipBillSplitGenerator
from generators.linear_fractional_generator import LinearFractionalGenerator
from generators.special_solution_equation_generator import SpecialSolutionEquationGenerator
from generators.exponent_mixed_rules_generator import ExponentMixedRulesGenerator
from generators.round_solids_generator import RoundSolidsGenerator
from generators.factor_gcf_generator import FactorGCFGenerator
from generators.factor_trinomial_generator import FactorTrinomialGenerator
from generators.factor_special_forms_generator import FactorSpecialFormsGenerator
from generators.factor_grouping_generator import FactorGroupingGenerator
from generators.quadratic_factoring_generator import QuadraticFactoringGenerator
from generators.quadratic_square_root_generator import QuadraticSquareRootGenerator
from generators.completing_square_generator import CompletingSquareGenerator
from generators.discriminant_generator import DiscriminantGenerator
from generators.radical_variable_simplify_generator import RadicalVariableSimplifyGenerator
from generators.radical_add_sub_generator import RadicalAddSubGenerator
from generators.radical_multiply_generator import RadicalMultiplyGenerator
from generators.radical_rationalize_generator import RadicalRationalizeGenerator
from generators.rational_exponent_generator import RationalExponentGenerator
from generators.radical_equation_generator import RadicalEquationGenerator
from generators.rational_expr_simplify_generator import RationalExprSimplifyGenerator
from generators.rational_expr_mult_div_generator import RationalExprMultDivGenerator
from generators.rational_expr_add_sub_generator import RationalExprAddSubGenerator
from generators.rational_equation_generator import RationalEquationGenerator
from generators.function_evaluation_generator import FunctionEvaluationGenerator
from generators.function_table_generator import FunctionTableGenerator
from generators.piecewise_evaluation_generator import PiecewiseEvaluationGenerator
from generators.function_operations_generator import FunctionOperationsGenerator
from generators.function_composition_generator import FunctionCompositionGenerator
from generators.domain_range_generator import DomainRangeGenerator
from generators.inverse_function_generator import InverseFunctionGenerator
from generators.arithmetic_sequence_generator import ArithmeticSequenceGenerator
from generators.geometric_sequence_generator import GeometricSequenceGenerator
from generators.recursive_explicit_generator import RecursiveExplicitGenerator
from generators.sigma_notation_generator import SigmaNotationGenerator
from generators.pascal_triangle_generator import PascalTriangleGenerator
from generators.complex_number_ops_generator import ComplexNumberOpsGenerator
from generators.complex_division_generator import ComplexDivisionGenerator
from generators.complex_quadratic_generator import ComplexQuadraticGenerator
from generators.polynomial_long_division_generator import PolynomialLongDivisionGenerator
from generators.synthetic_division_generator import SyntheticDivisionGenerator
from generators.horner_evaluation_generator import HornerEvaluationGenerator
from generators.remainder_factor_theorem_generator import RemainderFactorTheoremGenerator
from generators.rational_root_generator import RationalRootGenerator
from generators.polynomial_zeros_generator import PolynomialZerosGenerator
from generators.rational_function_features_generator import RationalFunctionFeaturesGenerator
from generators.exponential_model_generator import ExponentialModelGenerator
from generators.log_conversion_generator import LogConversionGenerator
from generators.log_properties_generator import LogPropertiesGenerator
from generators.exponential_equation_generator import ExponentialEquationGenerator
from generators.log_equation_generator import LogEquationGenerator
from generators.parabola_features_generator import ParabolaFeaturesGenerator
from generators.ellipse_features_generator import EllipseFeaturesGenerator
from generators.hyperbola_features_generator import HyperbolaFeaturesGenerator
from generators.conic_standard_form_generator import ConicStandardFormGenerator
from generators.nets_surface_area_generator import NetsSurfaceAreaGenerator
from generators.regular_polygon_area_generator import RegularPolygonAreaGenerator
from generators.similar_triangles_generator import SimilarTrianglesGenerator
from generators.geometric_mean_generator import GeometricMeanGenerator
from generators.distance_formula_generator import DistanceFormulaGenerator
from generators.midpoint_generator import MidpointGenerator
from generators.segment_partition_generator import SegmentPartitionGenerator
from generators.transformation_generator import TransformationGenerator
from generators.arc_sector_generator import ArcSectorGenerator
from generators.circle_angle_generator import CircleAngleGenerator
from generators.circle_equation_generator import CircleEquationGenerator
from generators.taxicab_geometry_generator import TaxicabGeometryGenerator
from generators.euler_characteristic_generator import EulerCharacteristicGenerator
from generators.hypercube_counting_generator import HypercubeCountingGenerator
from generators.right_triangle_trig_generator import RightTriangleTrigGenerator
from generators.special_right_triangle_generator import SpecialRightTriangleGenerator
from generators.angle_measure_generator import AngleMeasureGenerator
from generators.unit_circle_generator import UnitCircleGenerator
from generators.sinusoid_features_generator import SinusoidFeaturesGenerator
from generators.trig_six_functions_generator import TrigSixFunctionsGenerator
from generators.trig_identity_eval_generator import TrigIdentityEvalGenerator
from generators.trig_identity_verify_generator import TrigIdentityVerifyGenerator
from generators.trig_equation_generator import TrigEquationGenerator
from generators.triangle_solve_generator import TriangleSolveGenerator
from generators.triangle_area_sas_generator import TriangleAreaSASGenerator
from generators.polar_parametric_generator import PolarParametricGenerator
from generators.vector_ops_generator import VectorOpsGenerator
from generators.dot_product_generator import DotProductGenerator
from generators.matrix_ops_generator import MatrixOpsGenerator
from generators.determinant_generator import DeterminantGenerator
from generators.matrix_inverse_generator import MatrixInverseGenerator
from generators.cramers_rule_generator import CramersRuleGenerator
from generators.row_reduction_generator import RowReductionGenerator
from generators.limit_evaluation_generator import LimitEvaluationGenerator
from generators.derivative_limit_def_generator import DerivativeLimitDefGenerator
from generators.derivative_power_rule_generator import DerivativePowerRuleGenerator
from generators.derivative_product_quotient_generator import DerivativeProductQuotientGenerator
from generators.chain_rule_generator import ChainRuleGenerator
from generators.derivative_transcendental_generator import DerivativeTranscendentalGenerator
from generators.implicit_diff_generator import ImplicitDiffGenerator
from generators.log_diff_higher_order_generator import LogDiffHigherOrderGenerator
from generators.tangent_line_generator import TangentLineGenerator
from generators.related_rates_generator import RelatedRatesGenerator
from generators.linear_approx_generator import LinearApproxGenerator
from generators.lhopital_generator import LHopitalGenerator
from generators.curve_analysis_generator import CurveAnalysisGenerator
from generators.optimization_generator import OptimizationGenerator
from generators.mean_value_theorem_generator import MeanValueTheoremGenerator
from generators.antiderivative_generator import AntiderivativeGenerator
from generators.u_substitution_generator import USubstitutionGenerator
from generators.definite_integral_generator import DefiniteIntegralGenerator
from generators.riemann_sum_generator import RiemannSumGenerator
from generators.area_between_curves_generator import AreaBetweenCurvesGenerator
from generators.solid_revolution_generator import SolidRevolutionGenerator
from generators.separable_ode_generator import SeparableODEGenerator
from generators.integration_by_parts_generator import IntegrationByPartsGenerator
from generators.partial_fractions_generator import PartialFractionsGenerator
from generators.telescoping_generator import TelescopingGenerator
from generators.improper_integral_generator import ImproperIntegralGenerator
from generators.euler_method_generator import EulerMethodGenerator
from generators.logistic_growth_generator import LogisticGrowthGenerator
from generators.parametric_calculus_generator import ParametricCalculusGenerator
from generators.arc_length_generator import ArcLengthGenerator
from generators.series_convergence_generator import SeriesConvergenceGenerator
from generators.power_series_generator import PowerSeriesGenerator
from generators.taylor_series_generator import TaylorSeriesGenerator
from generators.five_number_summary_generator import FiveNumberSummaryGenerator
from generators.standard_deviation_generator import StandardDeviationGenerator
from generators.composite_arithmetic_generator import CompositeArithmeticGenerator
from generators.z_score_generator import ZScoreGenerator
from generators.frequency_table_generator import FrequencyTableGenerator
from generators.regression_generator import RegressionGenerator
from generators.expected_value_generator import ExpectedValueGenerator
from generators.confidence_interval_generator import ConfidenceIntervalGenerator
from generators.hypothesis_test_generator import HypothesisTestGenerator
from generators.two_sample_test_generator import TwoSampleTestGenerator
from generators.chi_square_generator import ChiSquareGenerator
from generators.type_error_power_generator import TypeErrorPowerGenerator
from generators.anova_generator import ANOVAGenerator
from generators.slope_inference_generator import SlopeInferenceGenerator
from generators.nonparametric_test_generator import NonparametricTestGenerator
from generators.empirical_cdf_generator import EmpiricalCDFGenerator
from generators.study_design_generator import StudyDesignGenerator
from generators.estimator_bias_enum_generator import EstimatorBiasEnumGenerator
from generators.mse_decomposition_generator import MSEDecompositionGenerator
from generators.fisher_information_generator import FisherInformationGenerator
from generators.sufficiency_factorization_generator import SufficiencyFactorizationGenerator
from generators.likelihood_ratio_test_generator import LikelihoodRatioTestGenerator
from generators.discrete_posterior_generator import DiscretePosteriorGenerator
from generators.permutation_combination_generator import PermutationCombinationGenerator
from generators.binomial_probability_generator import BinomialProbabilityGenerator
from generators.probability_addition_rule_generator import ProbabilityAdditionRuleGenerator
from generators.conditional_probability_generator import ConditionalProbabilityGenerator
from generators.geometric_probability_generator import GeometricProbabilityGenerator
from generators.geometric_distribution_generator import GeometricDistributionGenerator
from generators.finance_generator import FinanceGenerator
from generators.kinematics_generator import KinematicsGenerator
from generators.physics_formula_generator import PhysicsFormulaGenerator
from generators.base_conversion_generator import BaseConversionGenerator
from generators.base_arithmetic_generator import BaseArithmeticGenerator
from generators.bitwise_ops_generator import BitwiseOpsGenerator
from generators.modular_arithmetic_generator import ModularArithmeticGenerator
from generators.manual_square_root_generator import ManualSquareRootGenerator
from generators.calendar_arithmetic_generator import CalendarArithmeticGenerator
from generators.fermi_estimation_generator import FermiEstimationGenerator
from generators.partial_derivative_generator import PartialDerivativeGenerator
from generators.gradient_generator import GradientGenerator
from generators.multivar_chain_rule_generator import MultivarChainRuleGenerator
from generators.hessian_classify_generator import HessianClassifyGenerator
from generators.lagrange_multiplier_generator import LagrangeMultiplierGenerator
from generators.double_integral_generator import DoubleIntegralGenerator
from generators.triple_integral_generator import TripleIntegralGenerator
from generators.jacobian_generator import JacobianGenerator
from generators.div_curl_generator import DivCurlGenerator
from generators.line_integral_generator import LineIntegralGenerator
from generators.vector_theorem_generator import VectorTheoremGenerator
from generators.curve_geometry_generator import CurveGeometryGenerator
from generators.centroid_generator import CentroidGenerator
from generators.lu_decomposition_generator import LUDecompositionGenerator
from generators.subspace_basis_generator import SubspaceBasisGenerator
from generators.eigenvalue_generator import EigenvalueGenerator
from generators.diagonalization_generator import DiagonalizationGenerator
from generators.gram_schmidt_generator import GramSchmidtGenerator
from generators.qr_decomposition_generator import QRDecompositionGenerator
from generators.least_squares_generator import LeastSquaresGenerator
from generators.matrix_exponential_generator import MatrixExponentialGenerator
from generators.svd_generator import SVDGenerator
from generators.integrating_factor_generator import IntegratingFactorGenerator
from generators.exact_ode_generator import ExactODEGenerator
from generators.ode_substitution_generator import ODESubstitutionGenerator
from generators.second_order_ode_generator import SecondOrderODEGenerator
from generators.undetermined_coeff_generator import UndeterminedCoeffGenerator
from generators.variation_parameters_generator import VariationParametersGenerator
from generators.laplace_ivp_generator import LaplaceIVPGenerator
from generators.ode_system_generator import ODESystemGenerator
from generators.series_solution_generator import SeriesSolutionGenerator
from generators.stability_generator import StabilityGenerator
from generators.set_operations_generator import SetOperationsGenerator
from generators.relation_check_generator import RelationCheckGenerator
from generators.inclusion_exclusion_generator import InclusionExclusionGenerator
from generators.stars_and_bars_generator import StarsAndBarsGenerator
from generators.derangement_generator import DerangementGenerator
from generators.recurrence_generator import RecurrenceGenerator
from generators.master_theorem_generator import MasterTheoremGenerator
from generators.induction_verify_generator import InductionVerifyGenerator
from generators.counting_classics_generator import CountingClassicsGenerator
from generators.generating_function_generator import GeneratingFunctionGenerator
from generators.boolean_algebra_generator import BooleanAlgebraGenerator
from generators.graph_counting_generator import GraphCountingGenerator
from generators.dijkstra_generator import DijkstraGenerator
from generators.mst_generator import MSTGenerator
from generators.graph_traversal_generator import GraphTraversalGenerator
from generators.euler_circuit_generator import EulerCircuitGenerator
from generators.dp_table_generator import DPTableGenerator
from generators.algorithm_trace_generator import AlgorithmTraceGenerator
from generators.turing_machine_trace_generator import TuringMachineTraceGenerator
from generators.dfa_simulation_generator import DFASimulationGenerator
from generators.nfa_simulation_generator import NFASimulationGenerator
from generators.dfa_minimization_generator import DFAMinimizationGenerator
from generators.regex_to_automaton_generator import RegexToAutomatonGenerator
from generators.pda_simulation_generator import PDASimulationGenerator
from generators.cyk_parser_generator import CYKParserGenerator
from generators.dpll_trace_generator import DPLLTraceGenerator
from generators.resolution_proof_generator import ResolutionProofGenerator
from generators.unification_generator import UnificationGenerator
from generators.lambda_reduction_generator import LambdaReductionGenerator
from generators.extended_euclid_generator import ExtendedEuclidGenerator
from generators.modular_inverse_generator import ModularInverseGenerator
from generators.crt_generator import CRTGenerator
from generators.mod_exp_generator import ModExpGenerator
from generators.totient_generator import TotientGenerator
from generators.continued_fraction_generator import ContinuedFractionGenerator
from generators.quadratic_residue_generator import QuadraticResidueGenerator
from generators.jacobi_symbol_generator import JacobiSymbolGenerator
from generators.tonelli_shanks_generator import TonelliShanksGenerator
from generators.rsa_generator import RSAGenerator
from generators.diffie_hellman_generator import DiffieHellmanGenerator
from generators.primality_test_generator import PrimalityTestGenerator
from generators.pollard_factorization_generator import PollardFactorizationGenerator
from generators.baby_step_giant_step_generator import BabyStepGiantStepGenerator
from generators.cayley_table_generator import CayleyTableGenerator
from generators.cyclic_group_generator import CyclicGroupGenerator
from generators.permutation_group_generator import PermutationGroupGenerator
from generators.coset_generator import CosetGenerator
from generators.finite_field_generator import FiniteFieldGenerator
from generators.elliptic_curve_finite_field_generator import EllipticCurveFiniteFieldGenerator
from generators.ecdh_generator import ECDHGenerator
from generators.ecdsa_generator import ECDSAGenerator
from generators.lll_reduction_generator import LLLReductionGenerator
from generators.quaternion_generator import QuaternionGenerator
from generators.euler_formula_generator import EulerFormulaGenerator
from generators.de_moivre_generator import DeMoivreGenerator
from generators.complex_log_generator import ComplexLogGenerator
from generators.complex_locus_generator import ComplexLocusGenerator
from generators.mobius_transform_generator import MobiusTransformGenerator
from generators.fractal_iteration_generator import FractalIterationGenerator
from generators.cauchy_riemann_generator import CauchyRiemannGenerator
from generators.residue_generator import ResidueGenerator
from generators.contour_integral_generator import ContourIntegralGenerator
from generators.laurent_series_generator import LaurentSeriesGenerator
from generators.great_circle_generator import GreatCircleGenerator
from generators.spherical_excess_generator import SphericalExcessGenerator
from generators.spherical_triangle_generator import SphericalTriangleGenerator
from generators.hyperbolic_function_generator import HyperbolicFunctionGenerator
from generators.angle_defect_generator import AngleDefectGenerator
from generators.hyperbolic_distance_generator import HyperbolicDistanceGenerator
from generators.stereographic_generator import StereographicGenerator
from generators.fundamental_form_generator import FundamentalFormGenerator
from generators.christoffel_generator import ChristoffelGenerator
from generators.gaussian_curvature_generator import GaussianCurvatureGenerator
from generators.gauss_bonnet_generator import GaussBonnetGenerator
from generators.metric_arc_length_generator import MetricArcLengthGenerator
from generators.function_inner_product_generator import FunctionInnerProductGenerator
from generators.legendre_construction_generator import LegendreConstructionGenerator
from generators.hermitian_check_generator import HermitianCheckGenerator
from generators.tensor_product_generator import TensorProductGenerator
from generators.quantum_gate_generator import QuantumGateGenerator
from generators.partial_trace_generator import PartialTraceGenerator
from generators.density_matrix_generator import DensityMatrixGenerator
from generators.von_neumann_entropy_generator import VonNeumannEntropyGenerator
from generators.projector_generator import ProjectorGenerator
from generators.uncertainty_generator import UncertaintyGenerator
from generators.matrix_group_check_generator import MatrixGroupCheckGenerator
from generators.lie_exponential_generator import LieExponentialGenerator
from generators.structure_constant_generator import StructureConstantGenerator
from generators.pauli_algebra_generator import PauliAlgebraGenerator
from generators.casimir_generator import CasimirGenerator
from generators.index_gymnastics_generator import IndexGymnasticsGenerator
from generators.bch_generator import BCHGenerator
from generators.young_tableaux_generator import YoungTableauxGenerator
from generators.clebsch_gordan_generator import ClebschGordanGenerator
from generators.einstein_summation_generator import EinsteinSummationGenerator
from generators.index_raising_generator import IndexRaisingGenerator
from generators.riemann_tensor_generator import RiemannTensorGenerator
from generators.four_vector_generator import FourVectorGenerator
from generators.schwarzschild_generator import SchwarzschildGenerator
from generators.planck_units_generator import PlanckUnitsGenerator
from generators.hawking_generator import HawkingGenerator
from generators.casimir_force_generator import CasimirForceGenerator
from generators.natural_units_generator import NaturalUnitsGenerator
from generators.invariant_mass_generator import InvariantMassGenerator
from generators.conservation_law_generator import ConservationLawGenerator
from generators.quark_composition_generator import QuarkCompositionGenerator
from generators.branching_ratio_generator import BranchingRatioGenerator
from generators.cross_section_generator import CrossSectionGenerator
from generators.gamma_matrix_generator import GammaMatrixGenerator
from generators.grassmann_generator import GrassmannGenerator
from generators.running_coupling_generator import RunningCouplingGenerator
from generators.bisection_generator import BisectionGenerator
from generators.newton_raphson_generator import NewtonRaphsonGenerator
from generators.fixed_point_generator import FixedPointGenerator
from generators.interpolation_generator import InterpolationGenerator
from generators.finite_difference_generator import FiniteDifferenceGenerator
from generators.runge_kutta_generator import RungeKuttaGenerator
from generators.continuous_distribution_generator import ContinuousDistributionGenerator
from generators.named_distribution_generator import NamedDistributionGenerator
from generators.joint_distribution_generator import JointDistributionGenerator
from generators.mgf_generator import MGFGenerator
from generators.rv_transform_generator import RVTransformGenerator
from generators.mle_generator import MLEGenerator
from generators.method_of_moments_generator import MethodOfMomentsGenerator
from generators.bayesian_update_generator import BayesianUpdateGenerator
from generators.markov_chain_generator import MarkovChainGenerator
from generators.order_statistics_generator import OrderStatisticsGenerator
from generators.simplex_generator import SimplexGenerator
from generators.lp_corner_generator import LPCornerGenerator
from generators.gradient_descent_generator import GradientDescentGenerator
from generators.transportation_generator import TransportationGenerator
from generators.game_theory_generator import GameTheoryGenerator
from generators.or_formula_generator import ORFormulaGenerator
from generators.convolution_generator import ConvolutionGenerator
from generators.dft_generator import DFTGenerator
from generators.fourier_series_generator import FourierSeriesGenerator
from generators.separable_pde_generator import SeparablePDEGenerator
from generators.z_transform_generator import ZTransformGenerator
from generators.signal_arithmetic_generator import SignalArithmeticGenerator
from generators.transfer_function_generator import TransferFunctionGenerator
from generators.routh_hurwitz_generator import RouthHurwitzGenerator
from generators.projectile_motion_generator import ProjectileMotionGenerator
from generators.newtons_laws_generator import NewtonsLawsGenerator
from generators.collision_generator import CollisionGenerator
from generators.energy_conservation_generator import EnergyConservationGenerator
from generators.orbital_mechanics_generator import OrbitalMechanicsGenerator
from generators.statics_generator import StaticsGenerator
from generators.rotational_dynamics_generator import RotationalDynamicsGenerator
from generators.shm_generator import SHMGenerator
from generators.lagrangian_generator import LagrangianGenerator
from generators.hamiltonian_generator import HamiltonianGenerator
from generators.electrostatics_generator import ElectrostaticsGenerator
from generators.gauss_law_generator import GaussLawGenerator
from generators.transient_circuit_generator import TransientCircuitGenerator
from generators.ac_circuit_generator import ACCircuitGenerator
from generators.magnetism_generator import MagnetismGenerator
from generators.gas_law_generator import GasLawGenerator
from generators.first_law_generator import FirstLawGenerator
from generators.heat_engine_generator import HeatEngineGenerator
from generators.entropy_change_generator import EntropyChangeGenerator
from generators.calorimetry_generator import CalorimetryGenerator
from generators.partition_function_generator import PartitionFunctionGenerator
from generators.blackbody_generator import BlackbodyGenerator
from generators.quantum_formula_generator import QuantumFormulaGenerator
from generators.particle_in_box_generator import ParticleInBoxGenerator
from generators.wavefunction_generator import WavefunctionGenerator
from generators.spin_half_generator import SpinHalfGenerator
from generators.commutator_generator import CommutatorGenerator
from generators.ladder_operator_generator import LadderOperatorGenerator
from generators.hydrogen_atom_generator import HydrogenAtomGenerator
from generators.braket_generator import BraKetGenerator
from generators.special_relativity_generator import SpecialRelativityGenerator
from generators.relativistic_energy_generator import RelativisticEnergyGenerator
from generators.minkowski_interval_generator import MinkowskiIntervalGenerator
from generators.doppler_generator import DopplerGenerator
from generators.optics_generator import OpticsGenerator
from generators.interference_generator import InterferenceGenerator
from generators.standing_wave_generator import StandingWaveGenerator
from generators.stoichiometry_generator import StoichiometryGenerator
from generators.solution_chem_generator import SolutionChemGenerator
from generators.ph_calculation_generator import PHCalculationGenerator
from generators.gas_stoichiometry_generator import GasStoichiometryGenerator
from generators.equilibrium_ice_generator import EquilibriumICEGenerator
from generators.entropy_generator import EntropyGenerator
from generators.mutual_information_generator import MutualInformationGenerator
from generators.kl_divergence_generator import KLDivergenceGenerator
from generators.channel_capacity_generator import ChannelCapacityGenerator
from generators.bec_channel_generator import BECChannelGenerator
from generators.entropy_rate_markov_generator import EntropyRateMarkovGenerator
from generators.viterbi_generator import ViterbiGenerator
from generators.huffman_coding_generator import HuffmanCodingGenerator
from generators.arithmetic_coding_generator import ArithmeticCodingGenerator
from generators.lz_compression_generator import LZCompressionGenerator
from generators.convolutional_code_viterbi_generator import ConvolutionalCodeViterbiGenerator
from generators.reed_solomon_generator import ReedSolomonGenerator
from generators.hamming_code_generator import HammingCodeGenerator
from generators.crc_generator import CRCGenerator
from generators.kraft_inequality_generator import KraftInequalityGenerator
from generators.gradient_step_generator import GradientStepGenerator
from generators.perceptron_generator import PerceptronGenerator
from generators.backprop_generator import BackpropGenerator
from generators.naive_bayes_generator import NaiveBayesGenerator
from generators.information_gain_generator import InformationGainGenerator
from generators.kmeans_step_generator import KMeansStepGenerator
from generators.knn_generator import KNNGenerator
from generators.classifier_metrics_generator import ClassifierMetricsGenerator
from generators.matrix_calculus_generator import MatrixCalculusGenerator
from generators.matrix_norm_generator import MatrixNormGenerator
from generators.positive_definite_generator import PositiveDefiniteGenerator
from generators.cholesky_generator import CholeskyGenerator
from generators.pca_generator import PCAGenerator
from generators.embedding_similarity_generator import EmbeddingSimilarityGenerator
from generators.low_rank_approx_generator import LowRankApproxGenerator
from generators.kernel_evaluation_generator import KernelEvaluationGenerator
from generators.feature_map_generator import FeatureMapGenerator
from generators.kernel_validity_generator import KernelValidityGenerator
from generators.kernel_ridge_generator import KernelRidgeGenerator
from generators.svm_margin_generator import SVMMarginGenerator
from generators.kernel_perceptron_generator import KernelPerceptronGenerator
from generators.attention_generator import AttentionGenerator
from generators.softmax_gradient_generator import SoftmaxGradientGenerator
from generators.layer_norm_generator import LayerNormGenerator
from generators.activation_generator import ActivationGenerator
from generators.positional_encoding_generator import PositionalEncodingGenerator
from generators.param_count_generator import ParamCountGenerator
from generators.flops_memory_generator import FLOPsMemoryGenerator
from generators.scaling_law_generator import ScalingLawGenerator
from generators.adam_step_generator import AdamStepGenerator
from generators.lr_schedule_generator import LRScheduleGenerator
from generators.perplexity_generator import PerplexityGenerator
from generators.quantization_generator import QuantizationGenerator
from generators.annuity_generator import AnnuityGenerator
from generators.bond_pricing_generator import BondPricingGenerator
from generators.npv_irr_generator import NPVIRRGenerator
from generators.portfolio_generator import PortfolioGenerator
from generators.black_scholes_generator import BlackScholesGenerator
from generators.error_spotting_generator import ErrorSpottingGenerator
from generators.fill_in_step_generator import FillInStepGenerator
from generators.normal_table_generator import NormalTableGenerator
from generators.scaling_generator import ScalingGenerator, SimilarFiguresScaleGenerator
from generators.one_step_equation_generator import OneStepEquationGenerator
from generators.two_step_equation_generator import TwoStepEquationGenerator
from generators.one_step_inequality_generator import OneStepInequalityGenerator
from generators.two_step_inequality_generator import TwoStepInequalityGenerator
from generators.literal_equation_generator import LiteralEquationGenerator
from generators.absolute_value_equation_generator import AbsoluteValueEquationGenerator
from generators.absolute_value_inequality_generator import AbsoluteValueInequalityGenerator
from generators.compound_inequality_generator import CompoundInequalityGenerator
from generators.polynomial_inequality_generator import PolynomialInequalityGenerator
from generators.slope_two_points_generator import SlopeTwoPointsGenerator
from generators.slope_intercept_form_generator import SlopeInterceptFormGenerator
from generators.equation_from_two_points_generator import EquationFromTwoPointsGenerator
from generators.point_slope_generator import PointSlopeGenerator
from generators.standard_form_conversion_generator import StandardFormConversionGenerator
from generators.parallel_perpendicular_line_generator import ParallelPerpendicularLineGenerator
from generators.systems_substitution_generator import SystemsSubstitutionGenerator
from generators.systems_elimination_generator import SystemsEliminationGenerator
from generators.polynomial_add_sub_generator import PolynomialAddSubGenerator
from generators.monomial_mult_div_generator import MonomialMultDivGenerator
from generators.multiplying_binomials_generator import MultiplyingBinomialsGenerator
from generators.multiplying_polynomials_generator import MultiplyingPolynomialsGenerator
from generators.polynomial_div_monomial_generator import PolynomialDivMonomialGenerator
from generators.exponent_generator import (
    ExponentEvaluationGenerator,
    ExponentRulesGenerator,
    ScientificNotationGenerator,
    RootsAndRadicalsGenerator,
)
from generators.angle_relationships_generator import (
    AngleRelationshipsGenerator,
    AnglesWithParallelLinesGenerator,
    TriangleAngleSumGenerator,
)
from generators.circle_generator import CircleAreaCircumferenceGenerator
from generators.volume_3d_generator import (
    VolumePrismGenerator,
    VolumeCylinderGenerator,
    SurfaceAreaPrismGenerator,
    SurfaceAreaCylinderGenerator,
)
from generators.pythag_leg_generator import PythagoreanLegGenerator, PythagoreanWordProblemGenerator
from generators.statistics_generator import (
    MeanGenerator,
    MedianGenerator,
    ModeGenerator,
    RangeGenerator,
    MeanAbsoluteDeviationGenerator,
)
from generators.compound_probability_generator import (
    CompoundProbabilityIndependentGenerator,
    CompoundProbabilityDependentGenerator,
)
from generators.attribute_sorting_generator import AttributeSortingGenerator
from generators.one_to_one_correspondence_generator import OneToOneCorrespondenceGenerator
from generators.logical_connective_eval_generator import LogicalConnectiveEvalGenerator
from generators.operation_properties_generator import OperationPropertiesGenerator
from generators.set_membership_subset_generator import SetMembershipSubsetGenerator
from generators.set_builder_roster_generator import SetBuilderRosterGenerator
from generators.venn_region_count_generator import VennRegionCountGenerator
from generators.counterexample_search_generator import CounterexampleSearchGenerator
from generators.conditional_forms_generator import ConditionalFormsGenerator
from generators.knights_knaves_generator import KnightsKnavesGenerator
from generators.logic_grid_puzzle_generator import LogicGridPuzzleGenerator
from generators.truth_table_generator import TruthTableGenerator
from generators.wff_parsing_generator import WFFParsingGenerator
from generators.argument_form_generator import ArgumentFormGenerator
from generators.logical_equivalence_laws_generator import LogicalEquivalenceLawsGenerator
from generators.syllogism_generator import SyllogismGenerator
from generators.set_expression_generator import SetExpressionGenerator
from generators.set_identity_membership_table_generator import SetIdentityMembershipTableGenerator
from generators.set_counting_generator import SetCountingGenerator
from generators.function_properties_generator import FunctionPropertiesGenerator
from generators.equivalence_relation_generator import EquivalenceRelationGenerator
from generators.relation_operations_generator import RelationOperationsGenerator
from generators.relation_closure_generator import RelationClosureGenerator
from generators.partial_order_generator import PartialOrderGenerator
from generators.recursive_definition_unfold_generator import RecursiveDefinitionUnfoldGenerator
from generators.direct_proof_algebra_generator import DirectProofAlgebraGenerator
from generators.characteristic_vector_generator import CharacteristicVectorGenerator
from generators.set_algebra_laws_generator import SetAlgebraLawsGenerator
from generators.quantifier_negation_generator import QuantifierNegationGenerator
from generators.quantifier_finite_domain_generator import QuantifierFiniteDomainGenerator
from generators.prenex_normal_form_generator import PrenexNormalFormGenerator
from generators.english_to_logic_generator import EnglishToLogicGenerator
from generators.natural_deduction_generator import NaturalDeductionGenerator
from generators.semantic_tableau_generator import SemanticTableauGenerator
from generators.hereditarily_finite_set_generator import HereditarilyFiniteSetGenerator
from generators.peano_arithmetic_generator import PeanoArithmeticGenerator
from generators.integers_as_pairs_generator import IntegersAsPairsGenerator
from generators.rationals_as_pairs_generator import RationalsAsPairsGenerator
from generators.dedekind_cut_generator import DedekindCutGenerator
from generators.cantor_pairing_generator import CantorPairingGenerator
from generators.countability_bijection_generator import CountabilityBijectionGenerator
from generators.cantor_diagonal_generator import CantorDiagonalGenerator
from generators.ordinal_arithmetic_generator import OrdinalArithmeticGenerator
from generators.cardinal_arithmetic_generator import CardinalArithmeticGenerator
from generators.hilbert_axiom_derivation_generator import HilbertAxiomDerivationGenerator
from generators.godel_numbering_generator import GodelNumberingGenerator
from generators.combinatory_logic_generator import CombinatoryLogicGenerator
from generators.type_theory_generator import TypeTheoryGenerator
from generators.zf_axiom_identify_generator import ZFAxiomIdentifyGenerator
from generators.structure_isomorphism_generator import StructureIsomorphismGenerator
from generators.foundations_critic_generator import FoundationsCriticGenerator
from generators.multi_step_word_generator import MultiStepWordGenerator
from generators.integer_puzzle_word_generator import IntegerPuzzleWordGenerator
from generators.work_rate_generator import WorkRateGenerator
from generators.mixture_generator import MixtureGenerator
from generators.motion_word_generator import MotionWordGenerator
from generators.linear_model_word_generator import LinearModelWordGenerator
from generators.percent_chain_generator import PercentChainGenerator
from generators.money_life_generator import MoneyLifeGenerator
from generators.missing_information_generator import MissingInformationGenerator
from generators.method_discrimination_generator import MethodDiscriminationGenerator
from generators.plausibility_critic_generator import PlausibilityCriticGenerator
from generators.assumption_check_generator import AssumptionCheckGenerator
from generators.qualitative_reasoning_generator import QualitativeReasoningGenerator
from generators.mental_strategy_generator import MentalStrategyGenerator
from generators.magnitude_comparison_generator import MagnitudeComparisonGenerator
from generators.rounding_effect_generator import RoundingEffectGenerator
from generators.significant_figures_generator import SignificantFiguresGenerator
from generators.measurement_uncertainty_generator import MeasurementUncertaintyGenerator
from generators.geometry_in_context_generator import GeometryInContextGenerator
from generators.systems_word_generator import SystemsWordGenerator
from generators.quadratic_word_generator import QuadraticWordGenerator
from generators.growth_comparison_generator import GrowthComparisonGenerator
from generators.optimization_in_context_generator import OptimizationInContextGenerator
from generators.rate_of_change_interpret_generator import RateOfChangeInterpretGenerator
from generators.representation_translation_generator import RepresentationTranslationGenerator
from generators.formula_derivation_generator import FormulaDerivationGenerator
from generators.risk_communication_generator import RiskCommunicationGenerator
from generators.simpsons_paradox_generator import SimpsonsParadoxGenerator
from generators.statistical_literacy_generator import StatisticalLiteracyGenerator
from generators.index_and_growth_generator import IndexAndGrowthGenerator
from generators.decision_under_uncertainty_generator import DecisionUnderUncertaintyGenerator
from generators.square_cube_law_generator import SquareCubeLawGenerator
from generators.spatial_packing_generator import SpatialPackingGenerator
from generators.spatial_description_generator import SpatialDescriptionGenerator
from generators.scenario_generator import ScenarioGenerator
from generators.arithmetic_chain_generator import ArithmeticChainGenerator
from generators.digit_process_generator import DigitProcessGenerator
from generators.iterated_affine_map_generator import IteratedAffineMapGenerator
from generators.collatz_trace_generator import CollatzTraceGenerator
from generators.big_exact_division_generator import BigExactDivisionGenerator
from generators.radix_marathon_generator import RadixMarathonGenerator
from generators.compound_ledger_generator import CompoundLedgerGenerator
from generators.mod_exp_ladder_generator import ModExpLadderGenerator
from generators.recurrence_unroll_generator import RecurrenceUnrollGenerator
from generators.partial_sum_marathon_generator import PartialSumMarathonGenerator
from generators.iterated_composition_generator import IteratedCompositionGenerator
from generators.amortization_schedule_generator import AmortizationScheduleGenerator
from generators.register_machine_trace_generator import RegisterMachineTraceGenerator
from generators.token_rewrite_generator import TokenRewriteGenerator
from generators.ledger_audit_generator import LedgerAuditGenerator
from generators.pipeline_composition_generator import PipelineCompositionGenerator

# Import Helpers if needed (jid is used in generate methods, step/DELIM are used internally)
# from helpers import jid, step, DELIM # Not strictly needed here anymore

# -----------------------------------------------------------
# Op-code legend: see OPCODES.md (generated; regenerate with
# `python tools/gen_opcode_legend.py`). The vocabulary is descriptive and
# evolves organically — generators may introduce new op-codes freely.
# -----------------------------------------------------------

# ===========================================================================
# ALL_GENERATORS - Master list of all problem generators
# ===========================================================================
# For generators requiring args (like fractions, decimal add/sub),
# we instantiate one for each variant.
#
# The grade-band banners below are the source of truth for grade_level;
# per-class grade/difficulty metadata lives in curriculum.py and every class
# listed here must have a CURRICULUM entry (enforced by tests).
# ===========================================================================

ALL_GENERATORS = [
    # ===== ELEMENTARY (Grades 3-5) =====

    # --- Basic Arithmetic ---
    LongDivisionGenerator(),
    MultiDigitAdditionGenerator(),
    MultiDigitSubtractionGenerator(),
    MultiDigitMultiplicationGenerator(),
    AbacusAdditionGenerator(),
    AttributeSortingGenerator(),
    OneToOneCorrespondenceGenerator(),
    LogicalConnectiveEvalGenerator(),
    OperationPropertiesGenerator(),
    SetMembershipSubsetGenerator(),

    # --- Decimals ---
    DecimalAddSubGenerator('+'),
    DecimalAddSubGenerator('-'),
    DecimalMultGenerator(),
    DecimalDivGenerator(),

    # --- Fractions ---
    FractionOpGenerator('+'),
    FractionOpGenerator('-'),
    FractionOpGenerator('*'),
    FractionOpGenerator('/'),
    FractionComparisonGenerator(),
    MixedNumberOperationsRandom(),  # Random operation picker
    MixedNumberOperationGenerator('+'),
    MixedNumberOperationGenerator('-'),
    MixedNumberOperationGenerator('*'),
    MixedNumberOperationGenerator('/'),

    # --- Conversions ---
    FractionDecimalPercentConverter(),

    # --- Factors & Multiples ---
    FactorsGenerator(),
    PrimeFactorizationGenerator(),
    GCFGenerator(),
    LCMGenerator(),

    # --- Order of Operations ---
    OrderOfOperationsGenerator(),
    OrderOfOperationsGenerator("decimals"),
    OrderOfOperationsGenerator("mixed_numbers"),

    # --- Number Sense ---
    PlaceValueRoundingGenerator(),
    NumberComparisonGenerator(),
    DivisibilityClassificationGenerator(),

    # --- Geometry (Elementary) ---
    GeometryAreaPerimeterGenerator(),
    PolygonPerimeterGenerator(),
    VolumeRectPrismGenerator(),

    # --- Units & Measurement ---
    UnitConversionGenerator(),
    MultiStepUnitConversionGenerator(),
    RateConversionGenerator(),
    TemperatureConversionGenerator(),
    DimensionalAnalysisGenerator(),
    PercentWordProblemGenerator(modifier="plain"),
    PercentWordProblemGenerator(modifier="distractor"),
    PercentWordProblemGenerator(modifier="estimate_first"),
    PercentWordProblemGenerator(modifier="with_model"),
    RepeatingDecimalGenerator(),
    ProportionWordProblemGenerator(modifier="plain"),
    ProportionWordProblemGenerator(modifier="distractor"),
    ProportionWordProblemGenerator(modifier="estimate_first"),
    ProportionWordProblemGenerator(modifier="with_model"),

    # --- Data & Statistics (Elementary) ---
    SimpleStatsGenerator(),
    SimpleProbabilityGenerator(),
    LikelihoodLanguageGenerator(),
    SampleSpaceListGenerator(),
    ComplementProbabilityGenerator(),
    ExperimentalProbabilityGenerator(),
    FundamentalCountingPrincipleGenerator(),
    OddsProbabilityGenerator(),
    ProbabilityAxiomsFiniteGenerator(),
    TreeDiagramProbabilityGenerator(),
    RandomDigitSimulationGenerator(),
    TwoWayTableProbabilityGenerator(),
    VennProbabilityGenerator(),
    CountingToProbabilityGenerator(),
    ProbabilityMeasureGenerator(),
    ReliabilitySystemGenerator(),
    IndependenceCheckGenerator(),
    LawOfTotalProbabilityGenerator(),
    DiscreteUniformBernoulliGenerator(),
    PmfCdfQuantileGenerator(),
    ExpectationOfFunctionGenerator(),
    BayesMultipleHypothesesGenerator(),
    HypergeometricGenerator(),
    ClassicProbabilityPuzzlesGenerator(),
    NormalApproxBinomialGenerator(),
    LinearityOfExpectationGenerator(),
    CovarianceAlgebraGenerator(),
    ConditionalExpectationGenerator(),
    DistributionOfSumGenerator(),
    ProbabilityInequalityGenerator(),
    PGFGenerator(),
    NegativeBinomialGenerator(),
    GraphInterpretGenerator(),

    # ===== MIDDLE SCHOOL (Grades 6-8) =====

    # --- Integer Operations ---
    IntegerOperationsGenerator(),
    SetBuilderRosterGenerator(),
    VennRegionCountGenerator(),
    CounterexampleSearchGenerator(),
    ConditionalFormsGenerator(),
    KnightsKnavesGenerator(),
    LogicGridPuzzleGenerator(),
    SetOperationsGenerator(),

    # --- Ratios & Proportions ---
    UnitRateGenerator(modifier="plain"),
    UnitRateGenerator(modifier="distractor"),
    UnitRateGenerator(modifier="estimate_first"),
    UnitRateGenerator(modifier="with_model"),
    UnitRateFromTableGenerator(),
    RatioTableGenerator(),
    TipBillSplitGenerator(),
    ScalingGenerator(),
    SimilarFiguresScaleGenerator(),
    ProportionalRelationshipGenerator(),

    # --- Expressions & Equations ---
    OneStepEquationGenerator(),
    TwoStepEquationGenerator(),
    LinearSimpleGenerator(),
    LinearComplexGenerator(),
    SimplifyExpressionGenerator(),
    EvaluateExpressionGenerator(),

    # --- Inequalities ---
    OneStepInequalityGenerator(),
    TwoStepInequalityGenerator(),
    LinearFractionalGenerator(),
    SpecialSolutionEquationGenerator(),

    # --- Exponents & Roots ---
    ExponentEvaluationGenerator(),
    ExponentRulesGenerator(),
    ExponentRulesGenerator(base_style="decimal"),
    ExponentRulesGenerator(base_style="fraction"),
    ExponentMixedRulesGenerator(),
    ScientificNotationGenerator(),
    RootsAndRadicalsGenerator(),

    # --- Geometry (Middle School) ---
    AngleRelationshipsGenerator(),
    AnglesWithParallelLinesGenerator(),
    TriangleAngleSumGenerator(),
    CircleAreaCircumferenceGenerator(),
    VolumePrismGenerator(),
    VolumeCylinderGenerator(),
    SurfaceAreaPrismGenerator(),
    SurfaceAreaCylinderGenerator(),
    RoundSolidsGenerator(),
    PythagHypGenerator(),
    PythagoreanLegGenerator(),
    PythagoreanWordProblemGenerator(),

    # --- Statistics (Middle School) ---
    MeanGenerator(),
    MedianGenerator(),
    ModeGenerator(),
    RangeGenerator(),
    MeanAbsoluteDeviationGenerator(),

    # --- Probability (Middle School) ---
    CompoundProbabilityIndependentGenerator(),
    CompoundProbabilityDependentGenerator(),
    GeometricProbabilityGenerator(),
    FinanceGenerator(),
    KinematicsGenerator(),
    PhysicsFormulaGenerator(),
    BaseConversionGenerator(),
    BaseArithmeticGenerator(),
    BitwiseOpsGenerator(),
    ModularArithmeticGenerator(),
    ManualSquareRootGenerator(),
    CalendarArithmeticGenerator(),

    # ===== HIGH SCHOOL =====

    TruthTableGenerator(),
    WFFParsingGenerator(),
    ArgumentFormGenerator(),
    LogicalEquivalenceLawsGenerator(),
    SyllogismGenerator(),
    SetExpressionGenerator(),
    SetIdentityMembershipTableGenerator(),
    SetCountingGenerator(),
    FunctionPropertiesGenerator(),
    EquivalenceRelationGenerator(),
    RelationOperationsGenerator(),
    RelationClosureGenerator(),
    PartialOrderGenerator(),
    RecursiveDefinitionUnfoldGenerator(),
    DirectProofAlgebraGenerator(),
    CharacteristicVectorGenerator(),
    SetAlgebraLawsGenerator(),
    QuantifierNegationGenerator(),
    QuantifierFiniteDomainGenerator(),
    PrenexNormalFormGenerator(),
    EnglishToLogicGenerator(),
    NaturalDeductionGenerator(),
    SemanticTableauGenerator(),
    HereditarilyFiniteSetGenerator(),
    PeanoArithmeticGenerator(),
    IntegersAsPairsGenerator(),
    RationalsAsPairsGenerator(),
    DedekindCutGenerator(),
    CantorPairingGenerator(),
    CountabilityBijectionGenerator(),
    CantorDiagonalGenerator(),
    OrdinalArithmeticGenerator(),
    CardinalArithmeticGenerator(),
    HilbertAxiomDerivationGenerator(),
    GodelNumberingGenerator(),
    CombinatoryLogicGenerator(),
    TypeTheoryGenerator(),
    ZFAxiomIdentifyGenerator(),
    StructureIsomorphismGenerator(),
    FoundationsCriticGenerator(),

    # --- Algebra ---
    QuadraticGenerator(),
    PercentProblemGenerator(),
    LiteralEquationGenerator(),
    AbsoluteValueEquationGenerator(),
    AbsoluteValueInequalityGenerator(),
    CompoundInequalityGenerator(),
    PolynomialInequalityGenerator(),
    SlopeTwoPointsGenerator(),
    SlopeInterceptFormGenerator(),
    EquationFromTwoPointsGenerator(),
    PointSlopeGenerator(),
    StandardFormConversionGenerator(),
    ParallelPerpendicularLineGenerator(),
    SystemsSubstitutionGenerator(),
    SystemsEliminationGenerator(),
    PolynomialAddSubGenerator(),
    MonomialMultDivGenerator(),
    FactorGCFGenerator(),
    FactorTrinomialGenerator(),
    FactorTrinomialGenerator("general"),
    FactorSpecialFormsGenerator(),
    FactorGroupingGenerator(),
    QuadraticFactoringGenerator(),
    QuadraticSquareRootGenerator(),
    CompletingSquareGenerator(),
    DiscriminantGenerator(),
    RadicalVariableSimplifyGenerator(),
    RadicalAddSubGenerator(),
    RadicalMultiplyGenerator(),
    RadicalRationalizeGenerator(),
    RationalExponentGenerator(),
    RadicalEquationGenerator(),
    RationalExprSimplifyGenerator(),
    RationalExprMultDivGenerator(),
    RationalExprAddSubGenerator(),
    RationalEquationGenerator(),
    FunctionEvaluationGenerator(),
    FunctionTableGenerator(),
    PiecewiseEvaluationGenerator(),
    FunctionOperationsGenerator(),
    FunctionCompositionGenerator(),
    DomainRangeGenerator(),
    InverseFunctionGenerator(),
    ArithmeticSequenceGenerator(),
    GeometricSequenceGenerator(),
    RecursiveExplicitGenerator(),
    SigmaNotationGenerator(),
    PascalTriangleGenerator(),
    ComplexNumberOpsGenerator(),
    ComplexDivisionGenerator(),
    ComplexQuadraticGenerator(),
    PolynomialLongDivisionGenerator(),
    SyntheticDivisionGenerator(),
    HornerEvaluationGenerator(),
    RemainderFactorTheoremGenerator(),
    RationalRootGenerator(),
    PolynomialZerosGenerator(),
    RationalFunctionFeaturesGenerator(),
    ExponentialModelGenerator(),
    LogConversionGenerator(),
    LogPropertiesGenerator(),
    ExponentialEquationGenerator(),
    LogEquationGenerator(),
    ParabolaFeaturesGenerator(),
    EllipseFeaturesGenerator(),
    HyperbolaFeaturesGenerator(),
    ConicStandardFormGenerator(),
    NetsSurfaceAreaGenerator(),
    RegularPolygonAreaGenerator(),
    SimilarTrianglesGenerator(),
    GeometricMeanGenerator(),
    DistanceFormulaGenerator(),
    MidpointGenerator(),
    SegmentPartitionGenerator(),
    TransformationGenerator(),
    ArcSectorGenerator(),
    CircleAngleGenerator(),
    CircleEquationGenerator(),
    TaxicabGeometryGenerator(),
    EulerCharacteristicGenerator(),
    HypercubeCountingGenerator(),
    RightTriangleTrigGenerator(),
    SpecialRightTriangleGenerator(),
    AngleMeasureGenerator(),
    UnitCircleGenerator(),
    SinusoidFeaturesGenerator(),
    TrigSixFunctionsGenerator(),
    TrigIdentityEvalGenerator(),
    TrigIdentityVerifyGenerator(),
    TrigEquationGenerator(),
    TriangleSolveGenerator(),
    TriangleAreaSASGenerator(),
    PolarParametricGenerator(),
    VectorOpsGenerator(),
    DotProductGenerator(),
    MatrixOpsGenerator(),
    DeterminantGenerator(),
    MatrixInverseGenerator(),
    CramersRuleGenerator(),
    RowReductionGenerator(),
    LimitEvaluationGenerator(),
    DerivativeLimitDefGenerator(),
    DerivativePowerRuleGenerator(),
    DerivativeProductQuotientGenerator(),
    ChainRuleGenerator(),
    DerivativeTranscendentalGenerator(),
    ImplicitDiffGenerator(),
    LogDiffHigherOrderGenerator(),
    TangentLineGenerator(),
    RelatedRatesGenerator(),
    LinearApproxGenerator(),
    LHopitalGenerator(),
    CurveAnalysisGenerator(),
    OptimizationGenerator(),
    MeanValueTheoremGenerator(),
    AntiderivativeGenerator(),
    USubstitutionGenerator(),
    DefiniteIntegralGenerator(),
    RiemannSumGenerator(),
    AreaBetweenCurvesGenerator(),
    SolidRevolutionGenerator(),
    SeparableODEGenerator(),
    IntegrationByPartsGenerator(),
    PartialFractionsGenerator(),
    TelescopingGenerator(),
    ImproperIntegralGenerator(),
    EulerMethodGenerator(),
    LogisticGrowthGenerator(),
    ParametricCalculusGenerator(),
    ArcLengthGenerator(),
    SeriesConvergenceGenerator(),
    PowerSeriesGenerator(),
    TaylorSeriesGenerator(),
    FiveNumberSummaryGenerator(),
    StandardDeviationGenerator(),
    CompositeArithmeticGenerator(),
    ZScoreGenerator(),
    FrequencyTableGenerator(),
    RegressionGenerator(),
    ExpectedValueGenerator(),
    ConfidenceIntervalGenerator(),
    HypothesisTestGenerator(),
    TwoSampleTestGenerator(),
    ChiSquareGenerator(),
    PermutationCombinationGenerator(),
    BinomialProbabilityGenerator(),
    ProbabilityAdditionRuleGenerator(),
    ConditionalProbabilityGenerator(),
    GeometricDistributionGenerator(),
    FermiEstimationGenerator(),

    # --- Critic formats (see DESIGN.md "Derived Record Formats") ---
    ErrorSpottingGenerator(),
    FillInStepGenerator(),
    MultiDigitMultiplicationGenerator(estimate=True),
    LongDivisionGenerator(estimate=True),
    NormalTableGenerator(),
    MultiplyingBinomialsGenerator(),
    MultiplyingPolynomialsGenerator(),
    PolynomialDivMonomialGenerator(),
    PartialDerivativeGenerator(),
    GradientGenerator(),
    MultivarChainRuleGenerator(),
    HessianClassifyGenerator(),
    LagrangeMultiplierGenerator(),
    DoubleIntegralGenerator(),
    TripleIntegralGenerator(),
    JacobianGenerator(),
    DivCurlGenerator(),
    LineIntegralGenerator(),
    VectorTheoremGenerator(),
    CurveGeometryGenerator(),
    CentroidGenerator(),
    LUDecompositionGenerator(),
    SubspaceBasisGenerator(),
    EigenvalueGenerator(),
    DiagonalizationGenerator(),
    GramSchmidtGenerator(),
    QRDecompositionGenerator(),
    LeastSquaresGenerator(),
    MatrixExponentialGenerator(),
    SVDGenerator(),
    IntegratingFactorGenerator(),
    ExactODEGenerator(),
    ODESubstitutionGenerator(),
    SecondOrderODEGenerator(),
    UndeterminedCoeffGenerator(),
    VariationParametersGenerator(),
    LaplaceIVPGenerator(),
    ODESystemGenerator(),
    SeriesSolutionGenerator(),
    StabilityGenerator(),
    RelationCheckGenerator(),
    InclusionExclusionGenerator(),
    StarsAndBarsGenerator(),
    DerangementGenerator(),
    RecurrenceGenerator(),
    MasterTheoremGenerator(),
    InductionVerifyGenerator(),
    CountingClassicsGenerator(),
    GeneratingFunctionGenerator(),
    BooleanAlgebraGenerator(),
    GraphCountingGenerator(),
    DijkstraGenerator(),
    MSTGenerator(),
    GraphTraversalGenerator(),
    EulerCircuitGenerator(),
    DPTableGenerator(),
    AlgorithmTraceGenerator(),
    TuringMachineTraceGenerator(),
    DFASimulationGenerator(),
    NFASimulationGenerator(),
    DFAMinimizationGenerator(),
    RegexToAutomatonGenerator(),
    PDASimulationGenerator(),
    CYKParserGenerator(),
    DPLLTraceGenerator(),
    ResolutionProofGenerator(),
    UnificationGenerator(),
    LambdaReductionGenerator(),
    ExtendedEuclidGenerator(),
    ModularInverseGenerator(),
    CRTGenerator(),
    ModExpGenerator(),
    TotientGenerator(),
    ContinuedFractionGenerator(),
    QuadraticResidueGenerator(),
    JacobiSymbolGenerator(),
    TonelliShanksGenerator(),
    RSAGenerator(),
    DiffieHellmanGenerator(),
    PrimalityTestGenerator(),
    PollardFactorizationGenerator(),
    BabyStepGiantStepGenerator(),
    CayleyTableGenerator(),
    CyclicGroupGenerator(),
    PermutationGroupGenerator(),
    CosetGenerator(),
    FiniteFieldGenerator(),
    EllipticCurveFiniteFieldGenerator(),
    ECDHGenerator(),
    ECDSAGenerator(),
    LLLReductionGenerator(),
    QuaternionGenerator(),
    EulerFormulaGenerator(),
    DeMoivreGenerator(),
    ComplexLogGenerator(),
    ComplexLocusGenerator(),
    MobiusTransformGenerator(),
    FractalIterationGenerator(),
    CauchyRiemannGenerator(),
    ResidueGenerator(),
    ContourIntegralGenerator(),
    LaurentSeriesGenerator(),
    GreatCircleGenerator(),
    SphericalExcessGenerator(),
    SphericalTriangleGenerator(),
    HyperbolicFunctionGenerator(),
    AngleDefectGenerator(),
    HyperbolicDistanceGenerator(),
    StereographicGenerator(),
    FundamentalFormGenerator(),
    ChristoffelGenerator(),
    GaussianCurvatureGenerator(),
    GaussBonnetGenerator(),
    MetricArcLengthGenerator(),
    FunctionInnerProductGenerator(),
    LegendreConstructionGenerator(),
    HermitianCheckGenerator(),
    TensorProductGenerator(),
    QuantumGateGenerator(),
    PartialTraceGenerator(),
    DensityMatrixGenerator(),
    VonNeumannEntropyGenerator(),
    ProjectorGenerator(),
    UncertaintyGenerator(),
    MatrixGroupCheckGenerator(),
    LieExponentialGenerator(),
    StructureConstantGenerator(),
    PauliAlgebraGenerator(),
    CasimirGenerator(),
    IndexGymnasticsGenerator(),
    BCHGenerator(),
    YoungTableauxGenerator(),
    ClebschGordanGenerator(),
    EinsteinSummationGenerator(),
    IndexRaisingGenerator(),
    RiemannTensorGenerator(),
    FourVectorGenerator(),
    SchwarzschildGenerator(),
    PlanckUnitsGenerator(),
    HawkingGenerator(),
    CasimirForceGenerator(),
    NaturalUnitsGenerator(),
    InvariantMassGenerator(),
    ConservationLawGenerator(),
    QuarkCompositionGenerator(),
    BranchingRatioGenerator(),
    CrossSectionGenerator(),
    GammaMatrixGenerator(),
    GrassmannGenerator(),
    RunningCouplingGenerator(),
    BisectionGenerator(),
    NewtonRaphsonGenerator(),
    FixedPointGenerator(),
    InterpolationGenerator(),
    FiniteDifferenceGenerator(),
    RungeKuttaGenerator(),
    ContinuousDistributionGenerator(),
    NamedDistributionGenerator(),
    JointDistributionGenerator(),
    MGFGenerator(),
    RVTransformGenerator(),
    MLEGenerator(),
    MethodOfMomentsGenerator(),
    BayesianUpdateGenerator(),
    MarkovChainGenerator(),
    OrderStatisticsGenerator(),
    SimplexGenerator(),
    LPCornerGenerator(),
    GradientDescentGenerator(),
    TransportationGenerator(),
    GameTheoryGenerator(),
    ORFormulaGenerator(),
    ConvolutionGenerator(),
    DFTGenerator(),
    FourierSeriesGenerator(),
    SeparablePDEGenerator(),
    ZTransformGenerator(),
    SignalArithmeticGenerator(),
    TransferFunctionGenerator(),
    RouthHurwitzGenerator(),
    ProjectileMotionGenerator(),
    NewtonsLawsGenerator(),
    CollisionGenerator(),
    EnergyConservationGenerator(),
    OrbitalMechanicsGenerator(),
    StaticsGenerator(),
    RotationalDynamicsGenerator(),
    SHMGenerator(),
    LagrangianGenerator(),
    HamiltonianGenerator(),
    ElectrostaticsGenerator(),
    GaussLawGenerator(),
    TransientCircuitGenerator(),
    ACCircuitGenerator(),
    MagnetismGenerator(),
    GasLawGenerator(),
    FirstLawGenerator(),
    HeatEngineGenerator(),
    EntropyChangeGenerator(),
    CalorimetryGenerator(),
    PartitionFunctionGenerator(),
    BlackbodyGenerator(),
    QuantumFormulaGenerator(),
    ParticleInBoxGenerator(),
    WavefunctionGenerator(),
    SpinHalfGenerator(),
    CommutatorGenerator(),
    LadderOperatorGenerator(),
    HydrogenAtomGenerator(),
    BraKetGenerator(),
    SpecialRelativityGenerator(),
    RelativisticEnergyGenerator(),
    MinkowskiIntervalGenerator(),
    DopplerGenerator(),
    OpticsGenerator(),
    InterferenceGenerator(),
    StandingWaveGenerator(),
    StoichiometryGenerator(),
    SolutionChemGenerator(),
    PHCalculationGenerator(),
    GasStoichiometryGenerator(),
    EquilibriumICEGenerator(),
    EntropyGenerator(),
    MutualInformationGenerator(),
    KLDivergenceGenerator(),
    ChannelCapacityGenerator(),
    BECChannelGenerator(),
    EntropyRateMarkovGenerator(),
    ViterbiGenerator(),
    HuffmanCodingGenerator(),
    ArithmeticCodingGenerator(),
    LZCompressionGenerator(),
    ConvolutionalCodeViterbiGenerator(),
    ReedSolomonGenerator(),
    HammingCodeGenerator(),
    CRCGenerator(),
    KraftInequalityGenerator(),
    GradientStepGenerator(),
    PerceptronGenerator(),
    BackpropGenerator(),
    NaiveBayesGenerator(),
    InformationGainGenerator(),
    KMeansStepGenerator(),
    KNNGenerator(),
    ClassifierMetricsGenerator(),
    MatrixCalculusGenerator(),
    MatrixNormGenerator(),
    PositiveDefiniteGenerator(),
    CholeskyGenerator(),
    PCAGenerator(),
    EmbeddingSimilarityGenerator(),
    LowRankApproxGenerator(),
    KernelEvaluationGenerator(),
    FeatureMapGenerator(),
    KernelValidityGenerator(),
    KernelRidgeGenerator(),
    SVMMarginGenerator(),
    KernelPerceptronGenerator(),
    AttentionGenerator(),
    SoftmaxGradientGenerator(),
    LayerNormGenerator(),
    ActivationGenerator(),
    PositionalEncodingGenerator(),
    ParamCountGenerator(),
    FLOPsMemoryGenerator(),
    ScalingLawGenerator(),
    AdamStepGenerator(),
    LRScheduleGenerator(),
    PerplexityGenerator(),
    QuantizationGenerator(),
    AnnuityGenerator(),
    BondPricingGenerator(),
    NPVIRRGenerator(),
    PortfolioGenerator(),
    BlackScholesGenerator(),

    # Appended so generated op-code examples for existing classes remain stable.
    MultinomialProbabilityGenerator(),
    PoissonProcessGenerator(),
    RandomWalkGenerator(),
    MultiStateMarkovGenerator(),
    MonteCarloArithmeticGenerator(),
    ExpectedValueClassicsGenerator(),
    FiniteSigmaAlgebraGenerator(),
    BallotReflectionGenerator(),
    PolyaUrnGenerator(),
    MarkovStateClassificationGenerator(),
    MartingaleCheckGenerator(),
    ProbabilityCriticGenerator(),
    TallyFrequencyGenerator(),
    DotPlotGenerator(),
    FractionLinePlotGenerator(),
    StemAndLeafGenerator(),
    PopulationSampleGenerator(),
    BoxPlotGenerator(),
    HistogramConstructGenerator(),
    WeightedMeanGenerator(),
    MeanAdjustmentGenerator(),
    AlternativeMeansGenerator(),
    GroupedDataGenerator(),
    PercentileGenerator(),
    LinearTransformEffectGenerator(),
    ScatterPlotDescribeGenerator(),
    TwoWayTableGenerator(),
    CovarianceCorrelationGenerator(),
    EmpiricalRuleGenerator(),
    InverseNormalGenerator(),
    SamplingDistributionEnumGenerator(),
    CLTProbabilityGenerator(),
    PValueGenerator(),
    InferenceSetupGenerator(),
    TIntervalGenerator(),
    TypeErrorPowerGenerator(),
    ANOVAGenerator(),
    SlopeInferenceGenerator(),
    NonparametricTestGenerator(),
    EmpiricalCDFGenerator(),
    StudyDesignGenerator(),
    EstimatorBiasEnumGenerator(),
    MSEDecompositionGenerator(),
    FisherInformationGenerator(),
    SufficiencyFactorizationGenerator(),
    LikelihoodRatioTestGenerator(),
    DiscretePosteriorGenerator(),
    MultiStepWordGenerator(),
    IntegerPuzzleWordGenerator(),
    WorkRateGenerator(),
    MixtureGenerator(),
    MotionWordGenerator(),
    LinearModelWordGenerator(),
    PercentChainGenerator(),
    MoneyLifeGenerator(),
    MissingInformationGenerator(),
    MethodDiscriminationGenerator(),
    PlausibilityCriticGenerator(),
    AssumptionCheckGenerator(),
    QualitativeReasoningGenerator(),
    MentalStrategyGenerator(),
    MagnitudeComparisonGenerator(),
    RoundingEffectGenerator(),
    SignificantFiguresGenerator(),
    MeasurementUncertaintyGenerator(),
    GeometryInContextGenerator(),
    SystemsWordGenerator(),
    QuadraticWordGenerator(),
    GrowthComparisonGenerator(),
    OptimizationInContextGenerator(),
    RateOfChangeInterpretGenerator(),
    RepresentationTranslationGenerator(),
    FormulaDerivationGenerator(),
    RiskCommunicationGenerator(),
    SimpsonsParadoxGenerator(),
    StatisticalLiteracyGenerator(),
    IndexAndGrowthGenerator(),
    DecisionUnderUncertaintyGenerator(),
    SquareCubeLawGenerator(),
    SpatialPackingGenerator(),
    SpatialDescriptionGenerator(),
    ScenarioGenerator(),
    ArithmeticChainGenerator(),
    DigitProcessGenerator(),
    IteratedAffineMapGenerator(),
    CollatzTraceGenerator(),
    BigExactDivisionGenerator(),
    RadixMarathonGenerator(),
    CompoundLedgerGenerator(),
    ModExpLadderGenerator(),
    RecurrenceUnrollGenerator(),
    PartialSumMarathonGenerator(),
    IteratedCompositionGenerator(),
    AmortizationScheduleGenerator(),
    RegisterMachineTraceGenerator(),
    TokenRewriteGenerator(),
    LedgerAuditGenerator(),
    PipelineCompositionGenerator(),

    # --- (More High School generators coming soon) ---
]

# Instances excluded from the DEFAULT pool: MixedNumberOperationsRandom is a
# pure wrapper that re-rolls the four MixedNumberOperationGenerator variants,
# so including both would double-count the mixed-number skill. It stays
# registered and can still be requested explicitly via --generators.
DEFAULT_POOL_EXCLUDED = {"MixedNumberOperationsRandom"}


def resolve_pool(generators=None):
    """Returns the working generator pool.

    An explicit selection is honored as-is; the default pool is
    ALL_GENERATORS minus DEFAULT_POOL_EXCLUDED wrapper duplicates.
    """
    if generators is not None:
        pool = list(generators)
        if not pool:
            raise ValueError("No generators selected; cannot build dataset.")
        return pool
    return [g for g in ALL_GENERATORS
            if g.__class__.__name__ not in DEFAULT_POOL_EXCLUDED]


def select_generators(generator_arg: str):
    """
    Returns a filtered list of generators based on a comma-separated list of
    class names. If no argument is provided, returns all generators.
    """
    if not generator_arg:
        return ALL_GENERATORS

    requested = {name.strip() for name in generator_arg.split(",") if name.strip()}
    if not requested:
        return ALL_GENERATORS

    available = {gen.__class__.__name__ for gen in ALL_GENERATORS}
    missing = requested - available
    if missing:
        raise ValueError(f"Unknown generator(s): {', '.join(sorted(missing))}. "
                         f"Available: {', '.join(sorted(available))}")

    # All instances of each requested class (variant instances included).
    return [gen for gen in ALL_GENERATORS
            if gen.__class__.__name__ in requested]


def validate_example(example):
    """Structural validation of a generated example; raises ValueError.

    Deliberately vocabulary-agnostic: op-codes are not checked against any
    fixed list (the scratchpad vocabulary evolves organically), only the
    step *shape* and the required record fields are enforced.
    """
    validate_structure(example, final_op="Z", grade_levels=GRADE_LEVELS,
                       delim=DELIM)


def build_dataset(n=10_000, path="math_visible_dataset_refactored.jsonl", seed=None,
                  generators=None, weights=None, allow_duplicates=False):
    """Generates the dataset by calling the generate() method of chosen generators.

    Sampling is balanced per skill (generator class): each skill gets equal
    probability by default, and a skill's variant instances are chosen
    uniformly within it. `weights` (a {skill_name: float} dict or --weights
    spec string) overrides individual skill weights; unlisted skills keep
    weight 1.0.

    Exact repeats of (operation, problem) are skipped unless
    allow_duplicates is set. Returns a summary dict with per-instance stats.
    """
    return run_build(n=n, path=path, seed=seed,
                     gen_pool=resolve_pool(generators),
                     validate_fn=validate_example, stamp_fn=stamp_metadata,
                     weights=weights, allow_duplicates=allow_duplicates)

# ---------- Main Execution Block ----------
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Generate Quixi Math Dataset")
    parser.add_argument(
        "-n", "--num_examples",
        type=int,
        default=10000,
        help="Number of examples to generate."
    )
    parser.add_argument(
        "-o", "--output",
        type=str,
        default=None, # Default will be generated based on num_examples
        help="Output file path for the generated dataset. Defaults to quixi_math_<num_examples>.jsonl"
    )
    parser.add_argument(
        "-s", "--seed",
        type=int,
        default=None,
        help="Random seed for reproducibility. Omit to use system randomness."
    )
    # Removed --generate_dataset flag, sample is now default if no args given
    parser.add_argument(
        "--sample",
        action="store_true",
        help="Explicitly generate one sample from each generator type (this is also the default if no other args are given)."
    )
    parser.add_argument(
        "--generators",
        type=str,
        default=None,
        help="Comma-separated list of generator class names to include (e.g., 'MultiDigitAdditionGenerator,LongDivisionGenerator')."
    )
    parser.add_argument(
        "--weights",
        type=str,
        default=None,
        help="Skill weight overrides for dataset builds: inline 'SkillA=2.5,SkillB=0.5' "
             "or a path to a JSON file of {\"SkillName\": weight}. Unlisted skills "
             "keep weight 1.0. Ignored with --sample."
    )
    parser.add_argument(
        "--allow-duplicates",
        action="store_true",
        help="Keep exact repeats of (operation, problem) instead of skipping them."
    )

    args = parser.parse_args()
    selected_generators = select_generators(args.generators)

    # Determine the output filename if not provided
    if args.output is None:
        args.output = f"quixi_math_{args.num_examples}.jsonl"

    # Check if any arguments were passed (other than the script name itself)
    # OR if the --sample flag was explicitly used.
    # If no args, default to sample. If args are present but not --sample, generate dataset.
    if len(sys.argv) > 1 and not args.sample:
        # Generate dataset if arguments like -n, -o, -s are provided.
        # Only an explicit --generators selection overrides the default pool
        # (which excludes wrapper duplicates, see DEFAULT_POOL_EXCLUDED).
        explicit_selection = selected_generators if args.generators else None
        pool = resolve_pool(explicit_selection)
        names = ", ".join(gen.__class__.__name__ for gen in pool)
        print(f"Generating dataset with n={args.num_examples}, output={args.output}, seed={args.seed}...")
        print(f"Using generators: {names}")
        try:
            build_dataset(n=args.num_examples, path=args.output, seed=args.seed,
                          generators=explicit_selection, weights=args.weights,
                          allow_duplicates=args.allow_duplicates)
        except ValueError as e:
            print(f"ERROR: {e}")
            sys.exit(2)
        print("Dataset generation finished.")
    else:
        # Default action (no args) or explicit --sample: print samples
        action_reason = "Default Action" if len(sys.argv) == 1 else "--sample specified"
        print(f"Generating one sample from each generator type ({action_reason}):")
        print("(Use -n, -o, or -s arguments to generate the full dataset file)")
        if args.generators:
            names = ", ".join(gen.__class__.__name__ for gen in selected_generators)
            print(f"Limiting to generators: {names}")
        print("-" * 50)
        if args.seed is not None:
            random.seed(args.seed) # Use specified seed for samples

        for gen_instance in selected_generators:
            generator_name = gen_instance.__class__.__name__
            # Handle generators that take arguments in __init__
            if hasattr(gen_instance, 'op_symbol'):
                 generator_name += f" (op='{gen_instance.op_symbol}')"

            print(f"Generator: {generator_name}")
            try:
                example = stamp_metadata(gen_instance.generate(), gen_instance)
                print(json.dumps(example, indent=2, ensure_ascii=False))
            except Exception as e:
                print(f"  ERROR generating sample: {e}")
            print("-" * 50)
        print("Sample generation complete.")