nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/assumption/Assumption.js

@@ -0,0 +1,605 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assumption = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const common_1 = require("../../common/common");
+const Expression_1 = require("../expression/Expression");
+const constants_1 = require("../parser/constants");
+const Rational_1 = require("../rational/Rational");
+function isIdentStart(ch) {
+    return /[A-Za-z_]/.test(ch);
+}
+function isIdentChar(ch) {
+    return /[A-Za-z0-9_]/.test(ch);
+}
+function normalizeAssumptionValue(value) {
+    let decimal;
+    let exact;
+    if (Rational_1.Rational.isRational(value)) {
+        exact = Rational_1.Rational.makeCopy(value);
+        decimal = exact.toDecimal();
+    }
+    else {
+        decimal = typeof value === 'number' || typeof value === 'string' ? new decimal_js_1.default(value) : value;
+        if (decimal.isFinite()) {
+            exact = Rational_1.Rational.create(decimal.toString());
+        }
+    }
+    return { value: decimal, exact };
+}
+function compareBoundValues(a, aExact, b, bExact) {
+    let retval;
+    if (a.isFinite() && b.isFinite()) {
+        const left = aExact ?? Rational_1.Rational.create(a.toString());
+        const right = bExact ?? Rational_1.Rational.create(b.toString());
+        if (left.lt(right)) {
+            retval = -1;
+        }
+        else if (left.gt(right)) {
+            retval = 1;
+        }
+        else {
+            retval = 0;
+        }
+    }
+    else if (a.eq(b)) {
+        retval = 0;
+    }
+    else {
+        retval = a.lt(b) ? -1 : 1;
+    }
+    return retval;
+}
+function parseNumber(value) {
+    const v = String(value).toLowerCase();
+    if (v === 'inf' || v === 'infinity' || v === '+inf' || v === '+infinity') {
+        return new decimal_js_1.default(Infinity);
+    }
+    if (v === '-inf' || v === '-infinity') {
+        return new decimal_js_1.default(-Infinity);
+    }
+    const n = new decimal_js_1.default(v);
+    if (n.isNaN()) {
+        throw new Error(`Invalid Decimal: "${value}"`);
+    }
+    return n;
+}
+function compareNumericExpressionToBound(x, bound, boundExact) {
+    let retval = undefined;
+    if (x.isNegInf()) {
+        retval = bound.eq(-Infinity) ? 0 : -1;
+    }
+    else if (x.isPosInf()) {
+        retval = bound.eq(Infinity) ? 0 : 1;
+    }
+    else if (x.isNUM()) {
+        if (bound.isFinite()) {
+            const boundValue = boundExact ?? Rational_1.Rational.create(bound.toString());
+            const numericValue = x.getMultiplier();
+            if (numericValue.lt(boundValue)) {
+                retval = -1;
+            }
+            else if (numericValue.gt(boundValue)) {
+                retval = 1;
+            }
+            else {
+                retval = 0;
+            }
+        }
+        else {
+            retval = bound.lt(0) ? 1 : -1;
+        }
+    }
+    return retval;
+}
+/**
+ * Describes the admissible real values of a symbolic variable as one numeric interval.
+ *
+ * @remarks
+ * An `Assumption` is an interval constraint, not a symbolic theorem. It can prove
+ * relations when the interval bounds force an answer, disprove them when the bounds
+ * force the opposite answer, and otherwise reports an unknown result as `undefined`.
+ * Two variables having the same admissible interval therefore does not prove that the
+ * variables are equal.
+ *
+ * Instances are immutable. Repeated assumptions for a variable are intersected by
+ * the global assumption registry rather than modifying an existing interval.
+ *
+ * Finite bounds preserve an exact rational value internally. Decimal inputs therefore
+ * retain the exact value represented by their decimal text, while Rational inputs such
+ * as `1/3` are not rounded through Decimal precision before comparisons are made.
+ *
+ * The 2.0 assumption vocabulary covers a single real interval with numeric bounds.
+ * Integer, parity, complex-domain, relational (`x > y`), union, and general predicate
+ * assumptions are not represented by this class.
+ */
+class Assumption {
+    endExact;
+    startExact;
+    /** Runtime tag used by Nerdamer's assumption type guard. */
+    dataType = constants_1.ASSUMPTION;
+    /** Upper endpoint of the admissible interval. */
+    end;
+    /** Whether the interval contains exactly one finite value. */
+    isSingleton;
+    /** Lower endpoint of the admissible interval. */
+    start;
+    /**
+     * Creates a non-empty real interval.
+     *
+     * @remarks
+     * Infinite endpoints are normalized to open bounds. A zero-width interval is valid
+     * only when both endpoints are inclusive, in which case it represents one exact
+     * value. Rational inputs retain their exact value even when their Decimal projection
+     * is necessarily finite precision.
+     *
+     * @param start - Lower numeric endpoint.
+     * @param end - Upper numeric endpoint.
+     * @param startInclusive - Include the lower endpoint when it is finite.
+     * @param endInclusive - Include the upper endpoint when it is finite.
+     * @throws Error
+     * Thrown when a bound is `NaN`, the bounds are reversed, or the interval is empty.
+     */
+    constructor(start, end, startInclusive = true, endInclusive = true) {
+        const normalizedStart = normalizeAssumptionValue(start);
+        const normalizedEnd = normalizeAssumptionValue(end);
+        const startValue = normalizedStart.value;
+        const endValue = normalizedEnd.value;
+        const normalizedStartInclusive = startValue.isFinite() && !!startInclusive;
+        const normalizedEndInclusive = endValue.isFinite() && !!endInclusive;
+        const boundComparison = startValue.isNaN() || endValue.isNaN()
+            ? undefined
+            : compareBoundValues(startValue, normalizedStart.exact, endValue, normalizedEnd.exact);
+        // NaN cannot define an ordered interval, and equal endpoints describe a value
+        // only when that point belongs to both sides.
+        if (boundComparison === undefined ||
+            boundComparison > 0 ||
+            (boundComparison === 0 && !(normalizedStartInclusive && normalizedEndInclusive))) {
+            throw new Error(`Invalid interval: (${startValue}, ${endValue})`);
+        }
+        this.start = Object.freeze({
+            value: startValue,
+            inclusive: normalizedStartInclusive,
+        });
+        this.end = Object.freeze({
+            value: endValue,
+            inclusive: normalizedEndInclusive,
+        });
+        this.startExact = normalizedStart.exact;
+        this.endExact = normalizedEnd.exact;
+        this.isSingleton =
+            boundComparison === 0 && this.start.inclusive && this.end.inclusive;
+        Object.freeze(this);
+    }
+    /**
+     * Creates an interval extending upward from `x`.
+     *
+     * @param x - Lower endpoint.
+     * @param inclusive - Whether a finite lower endpoint belongs to the interval.
+     * @returns The interval `[x, +∞)` when inclusive, otherwise `(x, +∞)`.
+     */
+    static atLeast(x, inclusive = true) {
+        return new Assumption(x, Infinity, !!inclusive, false);
+    }
+    /**
+     * Creates an interval extending downward from `x`.
+     *
+     * @param x - Upper endpoint.
+     * @param inclusive - Whether a finite upper endpoint belongs to the interval.
+     * @returns The interval `(-∞, x]` when inclusive, otherwise `(-∞, x)`.
+     */
+    static atMost(x, inclusive = true) {
+        return new Assumption(-Infinity, x, false, !!inclusive);
+    }
+    /**
+     * Creates the singleton interval containing exactly `x`.
+     *
+     * @param x - The one admissible value.
+     * @returns The closed singleton interval `[x, x]`.
+     */
+    static exactly(x) {
+        return new Assumption(x, x, true, true);
+    }
+    static isAssumption(obj) {
+        return (0, common_1.isNerdamerNativeType)(obj, constants_1.ASSUMPTION);
+    }
+    /**
+     * Parses one numeric interval constraint such as `x >= 0` or `n < 10`.
+     *
+     * @remarks
+     * Whitespace is ignored. Variable names use the ASCII identifier form
+     * `[A-Za-z_][A-Za-z0-9_]*`. Supported operators are `=`, `==`, `>`, `>=`, `<`,
+     * and `<=`. Bounds are Decimal-compatible numeric literals; `inf`, `infinity`,
+     * `+inf`, `+infinity`, `-inf`, and `-infinity` are also accepted.
+     *
+     * Expressions such as `x > y`, `x = 1/2`, and property predicates such as
+     * `integer(x)` are outside the string assumption grammar. Parser assertive calls may
+     * still provide already-evaluated Rational bounds directly.
+     *
+     * @param expr - Constraint to parse.
+     * @returns The parsed symbol and its interval assumption.
+     * @throws Error
+     * Thrown when the constraint has an invalid identifier, operator, or numeric bound.
+     */
+    static parse(expr) {
+        if (typeof expr !== 'string') {
+            throw new Error(`Invalid assumption: "${String(expr)}"`);
+        }
+        const s = expr.replace(/\s+/g, '');
+        if (!s) {
+            throw new Error(`Invalid assumption: "${expr}"`);
+        }
+        // Must have at least a one-character identifier, operator, and value.
+        if (s.length < 3) {
+            throw new Error(`Invalid assumption: "${expr}"`);
+        }
+        let i = 0;
+        // Parse the variable identifier first. Assumptions are attached to plain
+        // variables rather than arbitrary symbolic expressions.
+        if (!isIdentStart(s[i])) {
+            throw new Error(`Expected identifier`);
+        }
+        let j = i + 1;
+        while (j < s.length && isIdentChar(s[j])) {
+            j++;
+        }
+        const symbol = s.slice(i, j);
+        i = j;
+        // Read the comparison operator separately so malformed combinations fail with
+        // an unsupported-operator error instead of being misread as part of the value.
+        let op = '';
+        while (i < s.length) {
+            const ch = s[i];
+            if (ch === '<' || ch === '>' || ch === '=') {
+                op += ch;
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        if (!op) {
+            throw new Error(`Missing operator`);
+        }
+        const valueStr = s.slice(i);
+        if (!valueStr) {
+            throw new Error(`Missing value`);
+        }
+        const value = parseNumber(valueStr);
+        let retval;
+        switch (op) {
+            case '>':
+                retval = { symbol, assumption: Assumption.atLeast(value, false) };
+                break;
+            case '>=':
+                retval = { symbol, assumption: Assumption.atLeast(value, true) };
+                break;
+            case '<':
+                retval = { symbol, assumption: Assumption.atMost(value, false) };
+                break;
+            case '<=':
+                retval = { symbol, assumption: Assumption.atMost(value, true) };
+                break;
+            case '=':
+            case '==':
+                retval = { symbol, assumption: Assumption.exactly(value) };
+                break;
+            default:
+                throw new Error(`Unsupported operator "${op}"`);
+        }
+        return retval;
+    }
+    /**
+     * Tests whether a numeric value belongs to this interval.
+     *
+     * @param x - Numeric value to test.
+     * @returns `true` when `x` satisfies both interval bounds.
+     */
+    contains(x) {
+        const value = normalizeAssumptionValue(x);
+        let retval = !value.value.isNaN();
+        if (retval &&
+            (compareBoundValues(value.value, value.exact, this.start.value, this.startExact) < 0 ||
+                compareBoundValues(value.value, value.exact, this.end.value, this.endExact) > 0)) {
+            retval = false;
+        }
+        else if (retval &&
+            compareBoundValues(value.value, value.exact, this.start.value, this.startExact) === 0 &&
+            !this.start.inclusive) {
+            retval = false;
+        }
+        else if (retval &&
+            compareBoundValues(value.value, value.exact, this.end.value, this.endExact) === 0 &&
+            !this.end.inclusive) {
+            retval = false;
+        }
+        return retval;
+    }
+    /**
+     * Determines whether values constrained by this interval are equal to `x`.
+     *
+     * @remarks
+     * Equality is proved only when both sides identify the same single value. It is
+     * disproved when the admissible values are disjoint. Overlapping ranges, including
+     * identical non-singleton ranges, return `undefined` because equality depends on the
+     * actual values chosen from those ranges.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when equality is forced, `false` when inequality is forced, or
+     * `undefined` when the available information permits either outcome.
+     */
+    eq(x) {
+        let retval = undefined;
+        if (Expression_1.Expression.isExpression(x)) {
+            const startComparison = compareNumericExpressionToBound(x, this.start.value, this.startExact);
+            const endComparison = compareNumericExpressionToBound(x, this.end.value, this.endExact);
+            if (startComparison !== undefined && endComparison !== undefined) {
+                if (startComparison < 0 ||
+                    endComparison > 0 ||
+                    (startComparison === 0 && !this.start.inclusive) ||
+                    (endComparison === 0 && !this.end.inclusive)) {
+                    retval = false;
+                }
+                else if (this.isSingleton) {
+                    retval = true;
+                }
+            }
+        }
+        else if (this.isSingleton && x.isSingleton) {
+            retval =
+                compareBoundValues(this.start.value, this.startExact, x.start.value, x.startExact) === 0;
+        }
+        else if (!this.overlaps(x)) {
+            retval = false;
+        }
+        return retval;
+    }
+    /**
+     * Returns the exact value represented by a singleton interval.
+     *
+     * @returns A numeric Expression when this interval is a singleton, otherwise
+     * `undefined`.
+     */
+    getSingletonValue() {
+        let retval;
+        if (this.isSingleton && this.startExact) {
+            retval = Expression_1.Expression.fromRational(this.startExact);
+        }
+        return retval;
+    }
+    /**
+     * Determines whether every value in this interval is strictly greater than `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `>` is forced, `false` when `<=` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    gt(x) {
+        let retval = undefined;
+        if (Expression_1.Expression.isExpression(x)) {
+            const startComparison = compareNumericExpressionToBound(x, this.start.value, this.startExact);
+            const endComparison = compareNumericExpressionToBound(x, this.end.value, this.endExact);
+            if (startComparison !== undefined && endComparison !== undefined) {
+                if (startComparison < 0 || (startComparison === 0 && !this.start.inclusive)) {
+                    retval = true;
+                }
+                else if (endComparison >= 0) {
+                    retval = false;
+                }
+            }
+        }
+        else {
+            const startVsEnd = compareBoundValues(this.start.value, this.startExact, x.end.value, x.endExact);
+            const endVsStart = compareBoundValues(this.end.value, this.endExact, x.start.value, x.startExact);
+            if (startVsEnd > 0 || (startVsEnd === 0 && (!this.start.inclusive || !x.end.inclusive))) {
+                retval = true;
+            }
+            else if (endVsStart <= 0) {
+                retval = false;
+            }
+        }
+        return retval;
+    }
+    /**
+     * Determines whether every value in this interval is greater than or equal to `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `>=` is forced, `false` when `<` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    gte(x) {
+        let retval = undefined;
+        if (Expression_1.Expression.isExpression(x)) {
+            const startComparison = compareNumericExpressionToBound(x, this.start.value, this.startExact);
+            const endComparison = compareNumericExpressionToBound(x, this.end.value, this.endExact);
+            if (startComparison !== undefined && endComparison !== undefined) {
+                if (startComparison <= 0) {
+                    retval = true;
+                }
+                else if (endComparison > 0 || (endComparison === 0 && !this.end.inclusive)) {
+                    retval = false;
+                }
+            }
+        }
+        else {
+            const startVsEnd = compareBoundValues(this.start.value, this.startExact, x.end.value, x.endExact);
+            const endVsStart = compareBoundValues(this.end.value, this.endExact, x.start.value, x.startExact);
+            if (startVsEnd >= 0) {
+                retval = true;
+            }
+            else if (endVsStart < 0 ||
+                (endVsStart === 0 && (!this.end.inclusive || !x.start.inclusive))) {
+                retval = false;
+            }
+        }
+        return retval;
+    }
+    /**
+     * Intersects this interval with another interval.
+     *
+     * Endpoint selection uses the exact finite representation retained by each interval,
+     * so repeated constraints do not lose rational precision while narrowing the range.
+     *
+     * @param x - Interval to intersect with this one.
+     * @returns The non-empty intersection, or `undefined` when the intervals are disjoint.
+     */
+    intersect(x) {
+        const startComparison = compareBoundValues(this.start.value, this.startExact, x.start.value, x.startExact);
+        const endComparison = compareBoundValues(this.end.value, this.endExact, x.end.value, x.endExact);
+        let startValue;
+        let startInclusive;
+        if (startComparison > 0) {
+            startValue = this.startExact ?? this.start.value;
+            startInclusive = this.start.inclusive;
+        }
+        else if (startComparison < 0) {
+            startValue = x.startExact ?? x.start.value;
+            startInclusive = x.start.inclusive;
+        }
+        else {
+            startValue = this.startExact ?? this.start.value;
+            startInclusive = this.start.inclusive && x.start.inclusive;
+        }
+        let endValue;
+        let endInclusive;
+        if (endComparison < 0) {
+            endValue = this.endExact ?? this.end.value;
+            endInclusive = this.end.inclusive;
+        }
+        else if (endComparison > 0) {
+            endValue = x.endExact ?? x.end.value;
+            endInclusive = x.end.inclusive;
+        }
+        else {
+            endValue = this.endExact ?? this.end.value;
+            endInclusive = this.end.inclusive && x.end.inclusive;
+        }
+        const normalizedStart = normalizeAssumptionValue(startValue);
+        const normalizedEnd = normalizeAssumptionValue(endValue);
+        const intersectionComparison = compareBoundValues(normalizedStart.value, normalizedStart.exact, normalizedEnd.value, normalizedEnd.exact);
+        let retval;
+        if (intersectionComparison < 0 ||
+            (intersectionComparison === 0 && startInclusive && endInclusive)) {
+            retval = new Assumption(startValue, endValue, startInclusive, endInclusive);
+        }
+        return retval;
+    }
+    /**
+     * Determines whether every value in this interval is strictly less than `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `<` is forced, `false` when `>=` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    lt(x) {
+        let retval = undefined;
+        if (Expression_1.Expression.isExpression(x)) {
+            const startComparison = compareNumericExpressionToBound(x, this.start.value, this.startExact);
+            const endComparison = compareNumericExpressionToBound(x, this.end.value, this.endExact);
+            if (startComparison !== undefined && endComparison !== undefined) {
+                if (endComparison > 0 || (endComparison === 0 && !this.end.inclusive)) {
+                    retval = true;
+                }
+                else if (startComparison <= 0) {
+                    retval = false;
+                }
+            }
+        }
+        else {
+            const endVsStart = compareBoundValues(this.end.value, this.endExact, x.start.value, x.startExact);
+            const startVsEnd = compareBoundValues(this.start.value, this.startExact, x.end.value, x.endExact);
+            if (endVsStart < 0 || (endVsStart === 0 && (!this.end.inclusive || !x.start.inclusive))) {
+                retval = true;
+            }
+            else if (startVsEnd >= 0) {
+                retval = false;
+            }
+        }
+        return retval;
+    }
+    /**
+     * Determines whether every value in this interval is less than or equal to `x`.
+     *
+     * @param x - Another interval-constrained value or a numeric expression.
+     * @returns `true` when `<=` is forced, `false` when `>` is forced, or `undefined`
+     * when the interval information permits both outcomes.
+     */
+    lte(x) {
+        let retval = undefined;
+        if (Expression_1.Expression.isExpression(x)) {
+            const startComparison = compareNumericExpressionToBound(x, this.start.value, this.startExact);
+            const endComparison = compareNumericExpressionToBound(x, this.end.value, this.endExact);
+            if (startComparison !== undefined && endComparison !== undefined) {
+                if (endComparison >= 0) {
+                    retval = true;
+                }
+                else if (startComparison < 0 || (startComparison === 0 && !this.start.inclusive)) {
+                    retval = false;
+                }
+            }
+        }
+        else {
+            const endVsStart = compareBoundValues(this.end.value, this.endExact, x.start.value, x.startExact);
+            const startVsEnd = compareBoundValues(this.start.value, this.startExact, x.end.value, x.endExact);
+            if (endVsStart <= 0) {
+                retval = true;
+            }
+            else if (startVsEnd > 0 ||
+                (startVsEnd === 0 && (!this.start.inclusive || !x.end.inclusive))) {
+                retval = false;
+            }
+        }
+        return retval;
+    }
+    /**
+     * Tests whether this interval and `x` share at least one admissible value.
+     *
+     * @param x - Interval to test for overlap.
+     * @returns `true` when the intersection is non-empty.
+     */
+    overlaps(x) {
+        const endVsStart = compareBoundValues(this.end.value, this.endExact, x.start.value, x.startExact);
+        const startVsEnd = compareBoundValues(this.start.value, this.startExact, x.end.value, x.endExact);
+        let retval = true;
+        if (endVsStart < 0 || startVsEnd > 0) {
+            retval = false;
+        }
+        else if (endVsStart === 0) {
+            retval = this.end.inclusive && x.start.inclusive;
+        }
+        else if (startVsEnd === 0) {
+            retval = this.start.inclusive && x.end.inclusive;
+        }
+        return retval;
+    }
+    /**
+     * Tests whether two objects describe the same interval constraint.
+     *
+     * @remarks
+     * This is structural interval equality and is separate from {@link eq}: two different
+     * variables may have identical intervals without being known to have the same value.
+     *
+     * @param x - Interval constraint to compare with this one.
+     * @returns `true` when both endpoints and their inclusivity are identical.
+     */
+    sameInterval(x) {
+        return (compareBoundValues(this.start.value, this.startExact, x.start.value, x.startExact) === 0 &&
+            compareBoundValues(this.end.value, this.endExact, x.end.value, x.endExact) === 0 &&
+            this.start.inclusive === x.start.inclusive &&
+            this.end.inclusive === x.end.inclusive);
+    }
+    /**
+     * Formats the interval using mathematical bracket notation.
+     *
+     * @returns A representation such as `[0, 10)` or `(-Infinity, Infinity)`.
+     */
+    toString() {
+        const l = this.start.inclusive ? '[' : '(';
+        const r = this.end.inclusive ? ']' : ')';
+        return `${l}${this.start.value}, ${this.end.value}${r}`;
+    }
+}
+exports.Assumption = Assumption;

package/output/core/classes/assumption/assertiveFunctions.d.ts

@@ -0,0 +1,6 @@
+import type { ParserEntity } from '../../types';
+export declare function assertEQ(a: ParserEntity, b: ParserEntity): ParserEntity;
+export declare function assertGT(a: ParserEntity, b: ParserEntity): ParserEntity;
+export declare function assertGTE(a: ParserEntity, b: ParserEntity): ParserEntity;
+export declare function assertLT(a: ParserEntity, b: ParserEntity): ParserEntity;
+export declare function assertLTE(a: ParserEntity, b: ParserEntity): ParserEntity;

package/output/core/classes/assumption/assertiveFunctions.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEQ = assertEQ;
+exports.assertGT = assertGT;
+exports.assertGTE = assertGTE;
+exports.assertLT = assertLT;
+exports.assertLTE = assertLTE;
+const errors_1 = require("../../errors");
+const Expression_1 = require("../expression/Expression");
+const assume_1 = require("./assume");
+const Assumption_1 = require("./Assumption");
+function assertRelation(a, b, operator) {
+    let bound;
+    // Assertive parser calls receive evaluated operands. Keep exact numeric values typed
+    // all the way into Assumption instead of converting Rational values through Decimal.
+    if (Expression_1.Expression.isExpression(b) && b.isNUM()) {
+        bound = b.getMultiplier();
+    }
+    else if (Expression_1.Expression.isExpression(b) && b.isPosInf()) {
+        bound = Infinity;
+    }
+    else if (Expression_1.Expression.isExpression(b) && b.isNegInf()) {
+        bound = -Infinity;
+    }
+    else {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'a real numeric value',
+            received: String(b),
+        }));
+    }
+    let assumption;
+    if (operator === '=') {
+        assumption = Assumption_1.Assumption.exactly(bound);
+    }
+    else if (operator === '>') {
+        assumption = Assumption_1.Assumption.atLeast(bound, false);
+    }
+    else if (operator === '>=') {
+        assumption = Assumption_1.Assumption.atLeast(bound, true);
+    }
+    else if (operator === '<') {
+        assumption = Assumption_1.Assumption.atMost(bound, false);
+    }
+    else {
+        assumption = Assumption_1.Assumption.atMost(bound, true);
+    }
+    (0, assume_1.assume)(String(a), assumption);
+    return a;
+}
+function assertEQ(a, b) {
+    return assertRelation(a, b, '=');
+}
+function assertGT(a, b) {
+    return assertRelation(a, b, '>');
+}
+function assertGTE(a, b) {
+    return assertRelation(a, b, '>=');
+}
+function assertLT(a, b) {
+    return assertRelation(a, b, '<');
+}
+function assertLTE(a, b) {
+    return assertRelation(a, b, '<=');
+}