@khanacademy/perseus 3.0.0 → 4.0.0

package/src/util/answer-types.js

@@ -1,861 +0,0 @@
-/* eslint-disable no-useless-escape */
-// @flow
-import * as KAS from "@khanacademy/kas";
-import * as i18n from "@khanacademy/wonder-blocks-i18n";
-import $ from "jquery";
-import _ from "underscore";
-
-import {Errors} from "../logging/log.js";
-import {PerseusError} from "../perseus-error.js";
-
-import KhanMath from "./math.js";
-
-const MAXERROR_EPSILON = Math.pow(2, -42);
-
-type Guess = $FlowFixMe;
-type Predicate = $FlowFixMe;
-
-// TOOD(kevinb): Figure out how this relates to KEScore in
-// perseus-all-package/types.js and see if there's a way to
-// unify these types.
-type Score = {|
-    empty: boolean,
-    correct: boolean,
-    message: ?string,
-    suppressAlmostThere?: ?boolean,
-    guess: Guess,
-    // It would be nice if we could ungraded required
-    ungraded?: boolean,
-|};
-
-export const errors = {
-    APPROXIMATED_PI_ERROR: (i18n._(
-        "Your answer is close, but you may " +
-            "have approximated pi. Enter your " +
-            "answer as a multiple of pi, like " +
-            "<code>12\\ \\text{pi}</code> or " +
-            "<code>2/3\\ \\text{pi}</code>",
-    ): string),
-    EXTRA_SYMBOLS_ERROR: (i18n._(
-        "We could not understand your " +
-            "answer. Please check your answer for extra " +
-            "text or symbols.",
-    ): string),
-    NEEDS_TO_BE_SIMPLFIED_ERROR: (i18n._(
-        "Your answer is almost correct, " + "but it needs to be simplified.",
-    ): string),
-    MISSING_PERCENT_ERROR: (i18n._(
-        "Your answer is almost correct, " +
-            "but it is missing a " +
-            "<code>\\%</code> at the end.",
-    ): string),
-    MULTIPLICATION_SIGN_ERROR: (i18n._(
-        "I'm a computer. I only understand " +
-            "multiplication if you use an asterisk " +
-            "(*) as the multiplication sign.",
-    ): string),
-    WRONG_CASE_ERROR: (i18n._(
-        "Your answer includes use of a variable with the wrong case.",
-    ): string),
-    WRONG_LETTER_ERROR: (i18n._(
-        "Your answer includes a wrong variable letter.",
-    ): string),
-};
-
-/*
- * Answer types
- *
- * Utility for creating answerable questions displayed in exercises
- *
- * Different answer types produce different kinds of input displays, and do
- * different kinds of checking on the solutions.
- *
- * Each of the objects contain two functions, setup and createValidator.
- *
- * The setup function takes a solutionarea and solution, and performs setup
- * within the solutionarea, and then returns an object which contains:
- *
- * answer: a function which, when called, will retrieve the current answer from
- *         the solutionarea, which can then be validated using the validator
- *         function
- * validator: a function returned from the createValidator function (defined
- *            below)
- * solution: the correct answer to the problem
- * showGuess: a function which, when given a guess, shows the guess within the
- *            provided solutionarea
- * showGuessCustom: a function which displays parts of a guess that are not
- *                  within the solutionarea; currently only used for custom
- *                  answers
- *
- * The createValidator function only takes a solution, and it returns a
- * function which can be used to validate an answer.
- *
- * The resulting validator function returns:
- * - true: if the answer is fully correct
- * - false: if the answer is incorrect
- * - "" (the empty string): if no answer has been provided (e.g. the answer box
- *   is left unfilled)
- * - a string: if there is some slight error
- *
- * In most cases, setup and createValidator don't really need the solution DOM
- * element so we have setupFunctional and createValidatorFunctional for them
- * which take only $solution.text() and $solution.data(). This makes it easier
- * to reuse specific answer types.
- *
- * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
- *
- */
-
-const KhanAnswerTypes = {
-    /*
-     * predicate answer type
-     *
-     * performs simple predicate-based checking of a numeric solution, with
-     * different kinds of number formats
-     *
-     * Uses the data-forms option on the solution to choose which number formats
-     * are acceptable. Available data-forms:
-     *
-     * - integer:  3
-     * - proper:   3/5
-     * - improper: 5/3
-     * - pi:       3 pi
-     * - log:      log(5)
-     * - percent:  15%
-     * - mixed:    1 1/3
-     * - decimal:  1.7
-     *
-     * The solution should be a predicate of the form:
-     *
-     * function(guess, maxError) {
-     *     return abs(guess - 3) < maxError;
-     * }
-     *
-     */
-    predicate: {
-        defaultForms: "integer, proper, improper, mixed, decimal",
-        createValidatorFunctional: function (
-            predicate: Predicate,
-            options: $FlowFixMe,
-        ): (Guess) => Score {
-            // Extract the options from the given solution object
-            options = _.extend(
-                {
-                    simplify: "required",
-                    ratio: false,
-                    forms: KhanAnswerTypes.predicate.defaultForms,
-                },
-                options,
-            );
-            let acceptableForms;
-            // this is maintaining backwards compatibility
-            // TODO(merlob) fix all places that depend on this, then delete
-            if (!_.isArray(options.forms)) {
-                acceptableForms = options.forms.split(/\s*,\s*/);
-            } else {
-                acceptableForms = options.forms;
-            }
-
-            // TODO(jack): remove options.inexact in favor of options.maxError
-            if (options.inexact === undefined) {
-                // If we aren't allowing inexact, ensure that we don't have a
-                // large maxError as well.
-                options.maxError = 0;
-            }
-            // Allow a small tolerance on maxError, to avoid numerical
-            // representation issues (2.3 should be correct for a solution of
-            // 2.45 with maxError=0.15).
-            options.maxError = +options.maxError + MAXERROR_EPSILON;
-
-            // If percent is an acceptable form, make sure it's the last one
-            // in the list so we don't prematurely complain about not having
-            // a percent sign when the user entered the correct answer in a
-            // different form (such as a decimal or fraction)
-            if (_.contains(acceptableForms, "percent")) {
-                acceptableForms = _.without(acceptableForms, "percent");
-                acceptableForms.push("percent");
-            }
-
-            // Take text looking like a fraction, and turn it into a number
-            const fractionTransformer = function (text) {
-                text = text
-                    // Replace unicode minus sign with hyphen
-                    .replace(/\u2212/, "-")
-                    // Remove space after +, -
-                    .replace(/([+-])\s+/g, "$1")
-                    // Remove leading/trailing whitespace
-                    .replace(/(^\s*)|(\s*$)/gi, "");
-
-                // Extract numerator and denominator
-                const match = text.match(/^([+-]?\d+)\s*\/\s*([+-]?\d+)$/);
-                // Fractions are represented as "-\frac{numerator}{denominator}"
-                // in Mobile device input instead of "numerator/denominator" as
-                // in web-browser.
-                const mobileDeviceMatch = text.match(
-                    /^([+-]?)\\frac\{([+-]?\d+)\}\{([+-]?\d+)\}$/,
-                );
-                const parsedInt = parseInt(text, 10);
-                if (match || mobileDeviceMatch) {
-                    let num;
-                    let denom;
-                    let simplified = true;
-                    if (match) {
-                        num = parseFloat(match[1]);
-                        denom = parseFloat(match[2]);
-                    } else {
-                        num = parseFloat(mobileDeviceMatch[2]);
-                        if (mobileDeviceMatch[1] === "-") {
-                            if (num < 0) {
-                                simplified = false;
-                            }
-                            num = -num;
-                        }
-                        denom = parseFloat(mobileDeviceMatch[3]);
-                    }
-
-                    simplified =
-                        simplified &&
-                        denom > 0 &&
-                        (options.ratio || denom !== 1) &&
-                        KhanMath.getGCD(num, denom) === 1;
-                    return [
-                        {
-                            value: num / denom,
-                            exact: simplified,
-                        },
-                    ];
-                }
-                if (!isNaN(parsedInt) && "" + parsedInt === text) {
-                    return [
-                        {
-                            value: parsedInt,
-                            exact: true,
-                        },
-                    ];
-                }
-
-                return [];
-            };
-
-            /*
-             * Different forms of numbers
-             *
-             * Each function returns a list of objects of the form:
-             *
-             * {
-             *    value: numerical value,
-             *    exact: true/false
-             * }
-             */
-            const forms = {
-                // integer, which is encompassed by decimal
-                integer: function (text) {
-                    // Compare the decimal form to the decimal form rounded to
-                    // an integer. Only accept if the user actually entered an
-                    // integer.
-                    const decimal = forms.decimal(text);
-                    const rounded = forms.decimal(text, 1);
-                    if (
-                        (decimal[0].value != null &&
-                            decimal[0].value === rounded[0].value) ||
-                        (decimal[1].value != null &&
-                            decimal[1].value === rounded[1].value)
-                    ) {
-                        return decimal;
-                    }
-                    return [];
-                },
-
-                // A proper fraction
-                proper: function (text) {
-                    return $.map(fractionTransformer(text), function (o) {
-                        // All fractions that are less than 1
-                        if (Math.abs(o.value) < 1) {
-                            return [o];
-                        }
-                        return [];
-                    });
-                },
-
-                // an improper fraction
-                improper: function (text) {
-                    return $.map(fractionTransformer(text), function (o) {
-                        // All fractions that are greater than 1
-                        if (Math.abs(o.value) >= 1) {
-                            return [o];
-                        }
-                        return [];
-                    });
-                },
-
-                // pi-like numbers
-                pi: function (text) {
-                    let match;
-                    let possibilities = [];
-
-                    // Replace unicode minus sign with hyphen
-                    text = text.replace(/\u2212/, "-");
-
-                    // - pi
-                    // (Note: we also support \pi (for TeX), p, tau (and \tau,
-                    // and t), pau.)
-                    if (
-                        (match = text.match(
-                            /^([+-]?)\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i,
-                        ))
-                    ) {
-                        possibilities = [
-                            {
-                                value: parseFloat(match[1] + "1"),
-                                exact: true,
-                            },
-                        ];
-
-                        // 5 / 6 pi
-                    } else if (
-                        (match = text.match(
-                            /^([+-]?\s*\d+\s*(?:\/\s*[+-]?\s*\d+)?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i,
-                        ))
-                    ) {
-                        possibilities = fractionTransformer(match[1]);
-
-                        // 4 5 / 6 pi
-                    } else if (
-                        (match = text.match(
-                            /^([+-]?)\s*(\d+)\s*([+-]?\d+)\s*\/\s*([+-]?\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i,
-                        ))
-                    ) {
-                        const sign = parseFloat(match[1] + "1");
-                        const integ = parseFloat(match[2]);
-                        const num = parseFloat(match[3]);
-                        const denom = parseFloat(match[4]);
-                        const simplified =
-                            num < denom && KhanMath.getGCD(num, denom) === 1;
-
-                        possibilities = [
-                            {
-                                value: sign * (integ + num / denom),
-                                exact: simplified,
-                            },
-                        ];
-
-                        // 5 pi / 6
-                    } else if (
-                        (match = text.match(
-                            /^([+-]?\s*\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\s*\d+))?$/i,
-                        ))
-                    ) {
-                        possibilities = fractionTransformer(
-                            match[1] + "/" + match[3],
-                        );
-
-                        // - pi / 4
-                    } else if (
-                        (match = text.match(
-                            /^([+-]?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\d+))?$/i,
-                        ))
-                    ) {
-                        possibilities = fractionTransformer(
-                            match[1] + "1/" + match[3],
-                        );
-
-                        // 0
-                    } else if (text === "0") {
-                        possibilities = [{value: 0, exact: true}];
-
-                        // 0.5 pi (fallback)
-                    } else if (
-                        (match = text.match(
-                            /^(.+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i,
-                        ))
-                    ) {
-                        possibilities = forms.decimal(match[1]);
-                    } else {
-                        possibilities = _.reduce(
-                            KhanAnswerTypes.predicate.defaultForms.split(
-                                /\s*,\s*/,
-                            ),
-                            function (memo, form) {
-                                return memo.concat(forms[form](text));
-                            },
-                            [],
-                        );
-
-                        // If the answer is a floating point number that's
-                        // near a multiple of pi, mark is as being possibly
-                        // an approximation of pi.  We actually check if
-                        // it's a plausible approximation of pi/12, since
-                        // sometimes the correct answer is like pi/3 or pi/4.
-                        // We also say it's a pi-approximation if it involves
-                        // x/7 (since 22/7 is an approximation of pi.)
-                        // Never mark an integer as being an approximation
-                        // of pi.
-                        let approximatesPi = false;
-                        const number = parseFloat(text);
-                        if (!isNaN(number) && number !== parseInt(text)) {
-                            const piMult = Math.PI / 12;
-                            const roundedNumber =
-                                piMult * Math.round(number / piMult);
-                            if (Math.abs(number - roundedNumber) < 0.01) {
-                                approximatesPi = true;
-                            }
-                        } else if (text.match(/\/\s*7/)) {
-                            approximatesPi = true;
-                        }
-                        if (approximatesPi) {
-                            _.each(possibilities, function (possibility) {
-                                possibility.piApprox = true;
-                            });
-                        }
-                        return possibilities;
-                    }
-
-                    let multiplier = Math.PI;
-                    if (text.match(/\\?tau|t|\u03c4/)) {
-                        multiplier = Math.PI * 2;
-                    }
-
-                    // We're taking an early stand along side xkcd in the
-                    // inevitable ti vs. pau debate... http://xkcd.com/1292
-                    if (text.match(/pau/)) {
-                        multiplier = Math.PI * 1.5;
-                    }
-
-                    $.each(possibilities, function (ix, possibility) {
-                        possibility.value *= multiplier;
-                    });
-                    return possibilities;
-                },
-
-                // Converts '' to 1 and '-' to -1 so you can write "[___] x"
-                // and accept sane things
-                coefficient: function (text) {
-                    let possibilities = [];
-
-                    // Replace unicode minus sign with hyphen
-                    text = text.replace(/\u2212/, "-");
-
-                    if (text === "") {
-                        possibilities = [{value: 1, exact: true}];
-                    } else if (text === "-") {
-                        possibilities = [{value: -1, exact: true}];
-                    }
-                    return possibilities;
-                },
-
-                // simple log(c) form
-                log: function (text) {
-                    let match;
-                    let possibilities = [];
-
-                    // Replace unicode minus sign with hyphen
-                    text = text.replace(/\u2212/, "-");
-                    text = text.replace(/[ \(\)]/g, "");
-
-                    if ((match = text.match(/^log\s*(\S+)\s*$/i))) {
-                        possibilities = forms.decimal(match[1]);
-                    } else if (text === "0") {
-                        possibilities = [{value: 0, exact: true}];
-                    }
-                    return possibilities;
-                },
-
-                // Numbers with percent signs
-                percent: function (text) {
-                    text = $.trim(text);
-                    // store whether or not there is a percent sign
-                    let hasPercentSign = false;
-
-                    if (text.indexOf("%") === text.length - 1) {
-                        text = $.trim(text.substring(0, text.length - 1));
-                        hasPercentSign = true;
-                    }
-
-                    const transformed = forms.decimal(text);
-                    $.each(transformed, function (ix, t) {
-                        t.exact = hasPercentSign;
-                        t.value = t.value / 100;
-                    });
-                    return transformed;
-                },
-
-                // Mixed numbers, like 1 3/4
-                mixed: function (text) {
-                    const match = text
-                        // Replace unicode minus sign with hyphen
-                        .replace(/\u2212/, "-")
-                        // Remove space after +, -
-                        .replace(/([+-])\s+/g, "$1")
-                        // Extract integer, numerator and denominator
-                        .match(/^([+-]?)(\d+)\s+(\d+)\s*\/\s*(\d+)$/);
-
-                    if (match) {
-                        const sign = parseFloat(match[1] + "1");
-                        const integ = parseFloat(match[2]);
-                        const num = parseFloat(match[3]);
-                        const denom = parseFloat(match[4]);
-                        const simplified =
-                            num < denom && KhanMath.getGCD(num, denom) === 1;
-
-                        return [
-                            {
-                                value: sign * (integ + num / denom),
-                                exact: simplified,
-                            },
-                        ];
-                    }
-
-                    return [];
-                },
-
-                // Decimal numbers -- compare entered text rounded to
-                // 'precision' Reciprical of the precision against the correct
-                // answer. We round to 1/1e10 by default, which is healthily
-                // less than machine epsilon but should be more than any real
-                // decimal answer would use. (The 'integer' answer type uses
-                // precision == 1.)
-                decimal: function (text: string, precision: number = 1e10) {
-                    const normal = function (text) {
-                        text = $.trim(text);
-
-                        const match = text
-                            // Replace unicode minus sign with hyphen
-                            .replace(/\u2212/, "-")
-                            // Remove space after +, -
-                            .replace(/([+-])\s+/g, "$1")
-                            // Extract integer, numerator and denominator. If
-                            // commas or spaces are used, they must be in the
-                            // "correct" places
-                            .match(
-                                /^([+-]?(?:\d{1,3}(?:[, ]?\d{3})*\.?|\d{0,3}(?:[, ]?\d{3})*\.(?:\d{3}[, ]?)*\d{1,3}))$/,
-                            );
-
-                        // You can't start a number with `0,`, to prevent us
-                        // interpeting '0.342' as correct for '342'
-                        const badLeadingZero = text.match(/^0[0,]*,/);
-
-                        if (match && !badLeadingZero) {
-                            let x = parseFloat(match[1].replace(/[, ]/g, ""));
-
-                            if (options.inexact === undefined) {
-                                x = Math.round(x * precision) / precision;
-                            }
-
-                            return x;
-                        }
-                    };
-
-                    const commas = function (text) {
-                        text = text.replace(/([\.,])/g, function (_, c) {
-                            return c === "." ? "," : ".";
-                        });
-                        return normal(text);
-                    };
-
-                    return [
-                        {value: normal(text), exact: true},
-                        {value: commas(text), exact: true},
-                    ];
-                },
-            };
-
-            // validator function
-            return function (guess: Guess): Score {
-                // The fallback variable is used in place of the answer, if no
-                // answer is provided (i.e. the field is left blank)
-                const fallback =
-                    options.fallback != null ? "" + options.fallback : "";
-
-                guess = $.trim(guess) || fallback;
-
-                const score: Score = {
-                    empty: guess === "",
-                    correct: false,
-                    message: (null: ?string),
-                    guess: guess,
-                };
-
-                // iterate over all the acceptable forms, and if one of the
-                // answers is correct, return true
-                $.each(acceptableForms, function (i, form) {
-                    const transformed = forms[form](guess);
-                    for (let j = 0, l = transformed.length; j < l; j++) {
-                        const val = transformed[j].value;
-                        const exact = transformed[j].exact;
-                        const piApprox = transformed[j].piApprox;
-                        // If a string was returned, and it exactly matches,
-                        // return true
-                        if (predicate(val, options.maxError)) {
-                            // If the exact correct number was returned,
-                            // return true
-                            if (exact || options.simplify === "optional") {
-                                score.correct = true;
-                                score.message = options.message || null;
-                                // If the answer is correct, don't say it's
-                                // empty. This happens, for example, with the
-                                // coefficient type where guess === "" but is
-                                // interpreted as "1" which is correct.
-                                score.empty = false;
-                            } else if (form === "percent") {
-                                // Otherwise, an error was returned
-                                score.empty = true;
-                                score.message = errors.MISSING_PERCENT_ERROR;
-                            } else {
-                                if (options.simplify !== "enforced") {
-                                    score.empty = true;
-                                }
-                                score.message =
-                                    errors.NEEDS_TO_BE_SIMPLFIED_ERROR;
-                            }
-                            // The return false below stops the looping of the
-                            // callback since predicate check  succeeded.
-                            // No more forms to look to verify the user guess.
-                            return false;
-                        }
-                        if (piApprox && predicate(val, Math.abs(val * 0.001))) {
-                            score.empty = true;
-                            score.message = errors.APPROXIMATED_PI_ERROR;
-                        }
-                    }
-                });
-
-                if (score.correct === false) {
-                    let interpretedGuess = false;
-                    _.each(forms, function (form) {
-                        const anyAreNaN = _.any(form(guess), function (t) {
-                            return t.value != null && !_.isNaN(t.value);
-                        });
-
-                        if (anyAreNaN) {
-                            interpretedGuess = true;
-                        }
-                    });
-                    if (!interpretedGuess) {
-                        score.empty = true;
-                        score.message = errors.EXTRA_SYMBOLS_ERROR;
-                        return score;
-                    }
-                }
-
-                return score;
-            };
-        },
-    },
-
-    /*
-     * number answer type
-     *
-     * wraps the predicate answer type to performs simple number-based checking
-     * of a solution
-     */
-    number: {
-        convertToPredicate: function (
-            correctAnswer: string,
-            options: $FlowFixMe,
-        ): Predicate {
-            const correctFloat = parseFloat(correctAnswer);
-
-            return [
-                function (guess, maxError) {
-                    return Math.abs(guess - correctFloat) < maxError;
-                },
-                $.extend({}, options, {type: "predicate"}),
-            ];
-        },
-        createValidatorFunctional: function (
-            correctAnswer: string,
-            options: $FlowFixMe,
-        ): (Guess) => Score {
-            return KhanAnswerTypes.predicate.createValidatorFunctional(
-                ...KhanAnswerTypes.number.convertToPredicate(
-                    correctAnswer,
-                    options,
-                ),
-            );
-        },
-    },
-
-    /*
-     * The expression answer type parses a given expression or equation
-     * and semantically compares it to the solution. In addition, instant
-     * feedback is provided by rendering the last answer that fully parsed.
-     *
-     * Parsing options:
-     * functions (e.g. data-functions="f g h")
-     *     A space or comma separated list of single-letter variables that
-     *     should be interpreted as functions. Case sensitive. "e" and "i"
-     *     are reserved.
-     *
-     *     no functions specified: f(x+y) == fx + fy
-     *     with "f" as a function: f(x+y) != fx + fy
-     *
-     * Comparison options:
-     * same-form (e.g. data-same-form)
-     *     If present, the answer must match the solution's structure in
-     *     addition to evaluating the same. Commutativity and excess negation
-     *     are ignored, but all other changes will trigger a rejection. Useful
-     *     for requiring a particular form of an equation, or if the answer
-     *     must be factored.
-     *
-     *     example question:    Factor x^2 + x - 2
-     *     example solution:    (x-1)(x+2)
-     *     accepted answers:    (x-1)(x+2), (x+2)(x-1), ---(-x-2)(-1+x), etc.
-     *     rejected answers:    x^2+x-2, x*x+x-2, x(x+1)-2, (x-1)(x+2)^1, etc.
-     *     rejection message:   Your answer is not in the correct form
-     *
-     * simplify (e.g. data-simplify)
-     *     If present, the answer must be fully expanded and simplified. Use
-     *     carefully - simplification is hard and there may be bugs, or you
-     *     might not agree on the definition of "simplified" used. You will
-     *     get an error if the provided solution is not itself fully expanded
-     *     and simplified.
-     *
-     *     example question:    Simplify ((n*x^5)^5) / (n^(-2)*x^2)^-3
-     *     example solution:    x^31 / n
-     *     accepted answers:    x^31 / n, x^31 / n^1, x^31 * n^(-1), etc.
-     *     rejected answers:    (x^25 * n^5) / (x^(-6) * n^6), etc.
-     *     rejection message:   Your answer is not fully expanded and simplified
-     *
-     * Rendering options:
-     * times (e.g. data-times)
-     *     If present, explicit multiplication (such as between numbers) will
-     *     be rendered with a cross/x symbol (TeX: \times) instead of the usual
-     *     center dot (TeX: \cdot).
-     *
-     *     normal rendering:    2 * 3^x -> 2 \cdot 3^{x}
-     *     but with "times":    2 * 3^x -> 2 \times 3^{x}
-     */
-    expression: {
-        parseSolution: function (
-            solutionString: string,
-            options: $FlowFixMe,
-        ): $FlowFixMe {
-            let solution = KAS.parse(solutionString, options);
-            if (!solution.parsed) {
-                throw new PerseusError(
-                    "The provided solution (" +
-                        solutionString +
-                        ") didn't parse.",
-                    Errors.InvalidInput,
-                );
-            } else if (options.simplified && !solution.expr.isSimplified()) {
-                throw new PerseusError(
-                    "The provided solution (" +
-                        solutionString +
-                        ") isn't fully expanded and simplified.",
-                    Errors.InvalidInput,
-                );
-            } else {
-                solution = solution.expr;
-            }
-            return solution;
-        },
-
-        createValidatorFunctional: function (
-            solution: $FlowFixMe,
-            options: $FlowFixMe,
-        ): (Guess) => Score {
-            return function (guess: Guess): Score {
-                const score = {
-                    empty: false,
-                    correct: false,
-                    message: (null: ?string),
-                    guess: guess,
-                    // Setting `ungraded` to true indicates that if the
-                    // guess doesn't match any of the solutions, the guess
-                    // shouldn't be marked as incorrect; instead, `message`
-                    // should be shown to the user. This is different from
-                    // setting `empty` to true, since the behavior of `empty`
-                    // is that `message` only will be shown if the guess is
-                    // graded as empty for every solution.
-                    ungraded: false,
-                };
-
-                // Don't bother parsing an empty input
-                if (!guess) {
-                    score.empty = true;
-                    return score;
-                }
-
-                const answer = KAS.parse(guess, options);
-
-                // An unsuccessful parse doesn't count as wrong
-                if (!answer.parsed) {
-                    score.empty = true;
-                    return score;
-                }
-
-                // Solution will need to be parsed again if we're creating
-                // this from a multiple question type
-                if (typeof solution === "string") {
-                    solution = KhanAnswerTypes.expression.parseSolution(
-                        solution,
-                        options,
-                    );
-                }
-
-                const result = KAS.compare(answer.expr, solution, options);
-
-                if (result.equal) {
-                    // Correct answer
-                    score.correct = true;
-                } else if (
-                    result.wrongVariableNames ||
-                    result.wrongVariableCase
-                ) {
-                    // We don't want to give people an error for getting the
-                    // variable names or the variable case wrong.
-                    // TODO(aasmund): This should ideally have been handled
-                    // under the `result.message` condition, but the
-                    // KAS messages currently aren't translatable.
-                    score.ungraded = true;
-                    score.message = result.wrongVariableCase
-                        ? errors.WRONG_CASE_ERROR
-                        : errors.WRONG_LETTER_ERROR;
-                    // Don't tell the use they're "almost there" in this case, that may not be true and isn't helpful.
-                    score.suppressAlmostThere = true;
-                } else if (result.message) {
-                    // Nearly correct answer
-                    // TODO(aasmund): This message also isn't translatable;
-                    // need to fix that in KAS
-                    score.message = result.message;
-                } else {
-                    // Replace x with * and see if it would have been correct
-                    // TODO(aasmund): I think this branch is effectively dead,
-                    // because the replacement will only work in situations
-                    // where the variables are wrong (except if the variable
-                    // is x, in which case the replacement won't work either),
-                    // which is handled by another branch. When we implement a
-                    // more sophisticated variable check, revive this or
-                    // remove it completely if it will never come into play.
-                    const answerX = KAS.parse(
-                        guess.replace(/[xX]/g, "*"),
-                        options,
-                    );
-                    if (answerX.parsed) {
-                        const resultX = KAS.compare(
-                            answerX.expr,
-                            solution,
-                            options,
-                        );
-                        if (resultX.equal) {
-                            score.ungraded = true;
-                            score.message = errors.MULTIPLICATION_SIGN_ERROR;
-                        } else if (resultX.message) {
-                            // TODO(aasmund): I18nize `score.message`
-                            score.message =
-                                resultX.message +
-                                " Also, I'm a computer. I only understand " +
-                                "multiplication if you use an " +
-                                "asterisk (*) as the multiplication " +
-                                "sign.";
-                        }
-                    }
-                }
-                return score;
-            };
-        },
-    },
-};
-
-export default KhanAnswerTypes;