From 8f0765f4035f5ecf8c19f43bf9ecf368ec1f7a90 Mon Sep 17 00:00:00 2001 From: Sean Huh Date: Tue, 10 Nov 2026 11:12:05 -0800 Subject: [PATCH] Decide int/double comparisons the verifier used to give up on PiperOrigin-RevId: 1018383137 --- .../dev/cel/verifier/CelNumericBounds.java | 2 +- .../dev/cel/verifier/CelVerifierZ3Impl.java | 23 ++- .../CelZ3CounterexampleGenerator.java | 11 +- .../cel/verifier/CelZ3OperatorTranslator.java | 51 +++---- .../dev/cel/verifier/CelZ3TypeSystem.java | 136 ++++++++++++++++++ .../dev/cel/verifier/axioms/AxiomHelpers.java | 48 ------- .../dev/cel/verifier/axioms/GreaterAxiom.java | 24 ++-- .../verifier/axioms/GreaterEqualsAxiom.java | 24 ++-- .../dev/cel/verifier/axioms/LessAxiom.java | 24 ++-- .../cel/verifier/axioms/LessEqualsAxiom.java | 24 ++-- .../cel/verifier/CelVerifierZ3ImplTest.java | 33 +++++ 11 files changed, 240 insertions(+), 160 deletions(-) diff --git a/verifier/src/main/java/dev/cel/verifier/CelNumericBounds.java b/verifier/src/main/java/dev/cel/verifier/CelNumericBounds.java index 8d2184c72..dc62622ee 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelNumericBounds.java +++ b/verifier/src/main/java/dev/cel/verifier/CelNumericBounds.java @@ -36,7 +36,7 @@ public final class CelNumericBounds { public static final String MAX_UINT64 = "18446744073709551615"; private static final double TWO_TO_63 = Math.scalb(1.0, 63); - private static final double TWO_TO_64 = Math.scalb(1.0, 64); + static final double TWO_TO_64 = Math.scalb(1.0, 64); @AutoValue abstract static class IntRange { diff --git a/verifier/src/main/java/dev/cel/verifier/CelVerifierZ3Impl.java b/verifier/src/main/java/dev/cel/verifier/CelVerifierZ3Impl.java index 7fade5e17..767bf4bda 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelVerifierZ3Impl.java +++ b/verifier/src/main/java/dev/cel/verifier/CelVerifierZ3Impl.java @@ -349,7 +349,8 @@ private CelVerificationResult search( solver.add(translator.getTypeConstraints().toArray(new BoolExpr[0])); // Pass 1: Search for an exact match. - Status status = checkSat(solver, condition, ctx.mkNot(taint)); + CelZ3TypeSystem typeSystem = translator.getTypeSystem(); + Status status = checkSat(solver, typeSystem, condition, ctx.mkNot(taint)); if (status == Status.SATISFIABLE) { CelWitness witness = extractWitness(ctx, translator, solver.getModel()); return isCounterexample @@ -361,7 +362,7 @@ private CelVerificationResult search( } // Pass 2: Search for an approximate match. - status = checkSat(solver, condition); + status = checkSat(solver, typeSystem, condition); if (status == Status.SATISFIABLE) { Model model = solver.getModel(); return CelVerificationResult.inconclusive( @@ -374,7 +375,7 @@ private CelVerificationResult search( } // Pass 3: Search for an unmodeled result. - status = checkSat(solver, unknownCondition, translator.hasUnmodeledResult()); + status = checkSat(solver, typeSystem, unknownCondition, translator.hasUnmodeledResult()); if (status == Status.SATISFIABLE) { return CelVerificationResult.inconclusive( inconclusiveReason(candidate, translator, solver.getModel(), taint)); @@ -390,11 +391,25 @@ private CelVerificationResult search( // Throws on a timeout. Leaves the assertions in place unless they're unsatisfiable, so the model // or the reason the solver gave up can be read. - private static Status checkSat(Solver solver, BoolExpr... assertions) + private static Status checkSat(Solver solver, CelZ3TypeSystem typeSystem, BoolExpr... assertions) throws CelVerificationException { solver.push(); solver.add(assertions); Status status = solver.check(); + // Each round defines at least one more double, so this terminates. Each round gets the full + // timeout; the rounds are bounded by the doubles in int/double comparisons. + while (status == Status.SATISFIABLE) { + ImmutableList definitions = + typeSystem.defineDoublesContradictedBy(solver.getModel()); + if (definitions.isEmpty()) { + break; + } + solver.pop(); + solver.add(definitions.toArray(new BoolExpr[0])); + solver.push(); + solver.add(assertions); + status = solver.check(); + } if (status == Status.UNSATISFIABLE) { solver.pop(); } else if (status == Status.UNKNOWN) { diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3CounterexampleGenerator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3CounterexampleGenerator.java index bbcb16403..c7aef6643 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3CounterexampleGenerator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3CounterexampleGenerator.java @@ -20,7 +20,6 @@ import com.google.common.collect.ImmutableMap; import com.google.common.primitives.UnsignedLong; import com.microsoft.z3.ArrayExpr; -import com.microsoft.z3.BitVecNum; import com.microsoft.z3.Context; import com.microsoft.z3.Expr; import com.microsoft.z3.FPNum; @@ -178,15 +177,9 @@ private static boolean isInRange(BigInteger val, long min, long max) { } private Value extractDouble(FPNum fpNum) { - if (fpNum.isNaN()) { - return Value.exact(Double.NaN, "double(\"NaN\")"); - } - // Z3 doubles are IEEE 754 binary64, so their bits convert exactly. - double value = - Double.longBitsToDouble( - ((BitVecNum) ctx.mkFPToIEEEBV(fpNum).simplify()).getBigInteger().longValue()); + double value = typeSystem.toJavaDouble(fpNum); return Value.exact( - value, Double.isInfinite(value) ? "double(\"" + value + "\")" : Double.toString(value)); + value, Double.isFinite(value) ? Double.toString(value) : "double(\"" + value + "\")"); } private static Value extractString(Expr arg, boolean isBytes) { diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java index d796fcf22..c7a422eb1 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java @@ -581,13 +581,6 @@ private BoolExpr getStaticallyKnownNumericEquality( } } - private BoolExpr mkIsFiniteDouble(Expr z3Expr) { - FPExpr fpVal = typeSystem.getDouble(z3Expr); - return ctx.mkAnd( - typeSystem.isDouble(z3Expr), - ctx.mkNot(ctx.mkOr(ctx.mkFPIsNaN(fpVal), ctx.mkFPIsInfinite(fpVal)))); - } - private BoolExpr getDynamicNumericEquality(Expr z3Expr0, Expr z3Expr1) { BoolExpr isIntOrUint0 = ctx.mkOr(typeSystem.isInt(z3Expr0), typeSystem.isUint(z3Expr0)); BoolExpr isIntOrUint1 = ctx.mkOr(typeSystem.isInt(z3Expr1), typeSystem.isUint(z3Expr1)); @@ -614,21 +607,9 @@ private BoolExpr getDynamicNumericEquality(Expr z3Expr0, Expr z3Expr1) { BoolExpr isIntOrUintAndDouble = ctx.mkAnd(isIntOrUint0, typeSystem.isDouble(z3Expr1)); BoolExpr isDoubleAndIntOrUint = ctx.mkAnd(typeSystem.isDouble(z3Expr0), isIntOrUint1); - FPExpr fpVal1 = typeSystem.getDouble(z3Expr1); - ArithExpr realVal0 = ctx.mkInt2Real(val0); - BoolExpr intDoubleEq = - ctx.mkAnd( - mkIsFiniteDouble(z3Expr1), - ctx.mkLe(realVal0, ctx.mkFPToReal(fpVal1)), - ctx.mkLe(ctx.mkFPToReal(fpVal1), realVal0)); - - FPExpr fpVal0 = typeSystem.getDouble(z3Expr0); - ArithExpr realVal1 = ctx.mkInt2Real(val1); - BoolExpr doubleIntEq = - ctx.mkAnd( - mkIsFiniteDouble(z3Expr0), - ctx.mkLe(realVal1, ctx.mkFPToReal(fpVal0)), - ctx.mkLe(ctx.mkFPToReal(fpVal0), realVal1)); + // Likewise fall back to 0.0, which the int/double comparisons never need to define. + FPExpr fpVal0 = guardedDouble(z3Expr0); + FPExpr fpVal1 = guardedDouble(z3Expr1); return (BoolExpr) CelZ3Exprs.SwitchBuilder.newBuilder(ctx) @@ -636,11 +617,17 @@ private BoolExpr getDynamicNumericEquality(Expr z3Expr0, Expr z3Expr1) { .addCase( bothDouble, ctx.mkFPEq(typeSystem.getDouble(z3Expr0), typeSystem.getDouble(z3Expr1))) - .addCase(isIntOrUintAndDouble, intDoubleEq) - .addCase(isDoubleAndIntOrUint, doubleIntEq) + .addCase(isIntOrUintAndDouble, typeSystem.intEqDouble(val0, fpVal1)) + .addCase(isDoubleAndIntOrUint, typeSystem.intEqDouble(val1, fpVal0)) .build(ctx.mkFalse()); } + private FPExpr guardedDouble(Expr z3Expr) { + return (FPExpr) + ctx.mkITE( + typeSystem.isDouble(z3Expr), typeSystem.getDouble(z3Expr), typeSystem.mkFpDouble(0.0)); + } + private boolean hasOptionalElements(TranslatedValue arg) { return arg.isLiteral(ExprKind.Kind.LIST) && !arg.celExpr().get().list().optionalIndices().isEmpty(); @@ -906,23 +893,19 @@ private Expr buildMapIndex( mapValues); // Double probes - FPExpr dVal = - (FPExpr) - (Expr) ctx.mkITE(isDouble, typeSystem.getDouble(rhsTrans), typeSystem.mkFpDouble(0.0)); - IntExpr dInt = ctx.mkReal2Int(ctx.mkFPToReal(dVal)); - BoolExpr doubleIsExact = - ctx.mkAnd( - isDouble, - ctx.mkNot(ctx.mkOr(ctx.mkFPIsNaN(dVal), ctx.mkFPIsInfinite(dVal))), - ctx.mkEq(ctx.mkInt2Real(dInt), ctx.mkFPToReal(dVal))); + FPExpr dVal = guardedDouble(rhsTrans); + IntExpr dInt = typeSystem.truncateDouble(dVal); + BoolExpr doubleIsExact = typeSystem.isIntegral(dVal); Expr doubleIntKey = typeSystem.wrapInt(dInt); Expr doubleUintKey = typeSystem.wrapUint(dInt); + // TODO: -2^63 finds an int key here, but the spec doesn't say whether it should. + BoolExpr doubleHasInt = ctx.mkAnd(doubleIsExact, ctx.mkNot(typeSystem.checkIntOverflow(dInt))); BoolExpr doubleHasUint = ctx.mkAnd(doubleIsExact, ctx.mkGe(dInt, ctx.mkInt(0))); ProbeResult doubleProbe = createProbeResult( inMapOrig, valOrig, - doubleIsExact, + doubleHasInt, doubleIntKey, doubleHasUint, doubleUintKey, diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java index 74a05cf5b..8a5da3deb 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java @@ -17,26 +17,37 @@ import com.google.auto.value.AutoValue; import com.google.common.collect.ImmutableList; import com.google.common.collect.ObjectArrays; +import com.google.common.math.DoubleMath; import com.google.common.primitives.UnsignedLongs; import com.microsoft.z3.ArithExpr; import com.microsoft.z3.ArrayExpr; +import com.microsoft.z3.BitVecNum; import com.microsoft.z3.BoolExpr; +import com.microsoft.z3.BoolSort; import com.microsoft.z3.Constructor; import com.microsoft.z3.Context; import com.microsoft.z3.DatatypeSort; import com.microsoft.z3.Expr; import com.microsoft.z3.FPExpr; +import com.microsoft.z3.FPNum; import com.microsoft.z3.FuncDecl; import com.microsoft.z3.IntExpr; +import com.microsoft.z3.IntNum; +import com.microsoft.z3.IntSort; +import com.microsoft.z3.Model; import com.microsoft.z3.SeqExpr; import com.microsoft.z3.SeqSort; import com.microsoft.z3.Sort; import dev.cel.common.internal.ProtoTimeUtils; import java.math.BigInteger; +import java.math.RoundingMode; import java.util.Arrays; import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Set; /** * Type system for mapping CEL values to Z3 expressions. @@ -141,6 +152,8 @@ public final class CelZ3TypeSystem { private static final String FUNC_MSG_PRESENCE = "msg_presence"; private static final String FUNC_MSG_TYPE_NAME = "msg_type_name"; private static final String FUNC_HAS_TRUNCATED_TYPE_CONSTRAINT = "!has_truncated_type_constraint"; + private static final String FUNC_TRUNCATE_DOUBLE = "!truncate_double"; + private static final String FUNC_HAS_FRACTION = "!has_fraction"; private final Context ctx; private final Map> funcDeclCache; @@ -180,6 +193,10 @@ public final class CelZ3TypeSystem { private final FuncDecl msgPresenceFunc; private final FuncDecl msgTypeNameFunc; private final FuncDecl hasTruncatedTypeConstraintFunc; + private final FuncDecl truncateDoubleFunc; + private final FuncDecl hasFractionFunc; + // Doubles whose truncation and fraction are still uninterpreted, in order of first use. + private final Set undefinedDoubles; private final boolean parameterizeUnknowns; @@ -786,6 +803,120 @@ public BoolExpr checkUintOverflow(ArithExpr result) { ctx.mkGt(result, ctx.mkInt(CelNumericBounds.MAX_UINT64)), ctx.mkLt(result, ctx.mkInt(0))); } + // Int/double comparisons are exact for |n| < 2^64. A double's truncation and fraction stay + // uninterpreted until defineDoublesContradictedBy refutes a model that gets them wrong. + + /** Returns whether the integer {@code n} equals the double {@code d}. */ + BoolExpr intEqDouble(IntExpr n, FPExpr d) { + return ctx.mkAnd(isIntegral(d), ctx.mkEq(n, truncateDouble(d))); + } + + /** Returns whether the integer {@code n} is less than the double {@code d}. */ + public BoolExpr intLtDouble(IntExpr n, FPExpr d) { + IntExpr t = truncateDouble(d); + return ctx.mkOr( + ctx.mkFPGEq(d, mkFpDouble(CelNumericBounds.TWO_TO_64)), + ctx.mkAnd( + isBelowTwoTo64(d), + ctx.mkOr( + ctx.mkLt(n, t), + ctx.mkAnd(ctx.mkEq(n, t), hasFraction(d), ctx.mkNot(ctx.mkFPIsNegative(d)))))); + } + + /** Returns whether the double {@code d} is less than the integer {@code n}. */ + public BoolExpr doubleLtInt(FPExpr d, IntExpr n) { + IntExpr t = truncateDouble(d); + return ctx.mkOr( + ctx.mkFPLEq(d, ctx.mkFPNeg(mkFpDouble(CelNumericBounds.TWO_TO_64))), + ctx.mkAnd( + isBelowTwoTo64(d), + ctx.mkOr( + ctx.mkLt(t, n), ctx.mkAnd(ctx.mkEq(n, t), hasFraction(d), ctx.mkFPIsNegative(d))))); + } + + /** Returns whether the integer {@code n} is at most the double {@code d}. */ + public BoolExpr intLeDouble(IntExpr n, FPExpr d) { + return ctx.mkAnd(ctx.mkNot(ctx.mkFPIsNaN(d)), ctx.mkNot(doubleLtInt(d, n))); + } + + /** Returns whether the double {@code d} is at most the integer {@code n}. */ + public BoolExpr doubleLeInt(FPExpr d, IntExpr n) { + return ctx.mkAnd(ctx.mkNot(ctx.mkFPIsNaN(d)), ctx.mkNot(intLtDouble(n, d))); + } + + /** Returns whether {@code d} is an integer of magnitude below 2^64. */ + BoolExpr isIntegral(FPExpr d) { + return ctx.mkAnd(isBelowTwoTo64(d), ctx.mkNot(hasFraction(d))); + } + + /** Returns {@code d} truncated toward zero, if its magnitude is below 2^64. */ + IntExpr truncateDouble(FPExpr d) { + return (IntExpr) + ctx.mkITE(ctx.mkFPIsZero(d), ctx.mkInt(0), applyUndefined(truncateDoubleFunc, d)); + } + + /** Returns exact definitions for the tracked doubles whose values {@code model} gets wrong. */ + ImmutableList defineDoublesContradictedBy(Model model) { + ImmutableList.Builder definitions = ImmutableList.builder(); + for (Iterator it = undefinedDoubles.iterator(); it.hasNext(); ) { + FPExpr d = it.next(); + double value = toJavaDouble((FPNum) model.evaluate(d, /* completion= */ true)); + // The comparisons don't read the functions at NaN, zero, infinities, or beyond 2^64. + if (Double.isNaN(value) || value == 0 || Math.abs(value) >= CelNumericBounds.TWO_TO_64) { + continue; + } + BigInteger truncated = + ((IntNum) model.evaluate(ctx.mkApp(truncateDoubleFunc, d), /* completion= */ true)) + .getBigInteger(); + boolean hasFraction = + model.evaluate(ctx.mkApp(hasFractionFunc, d), /* completion= */ true).isTrue(); + if (!truncated.equals(DoubleMath.roundToBigInteger(value, RoundingMode.DOWN)) + || hasFraction == DoubleMath.isMathematicalInteger(value)) { + it.remove(); + definitions.add(defineDouble(d)); + } + } + return definitions.build(); + } + + /** Converts a Z3 double to the Java double with the same IEEE 754 bits (or NaN). */ + double toJavaDouble(FPNum fpNum) { + // Z3 doesn't simplify the bits of NaN to a numeral. + return fpNum.isNaN() + ? Double.NaN + : Double.longBitsToDouble( + ((BitVecNum) ctx.mkFPToIEEEBV(fpNum).simplify()).getBigInteger().longValue()); + } + + private BoolExpr hasFraction(FPExpr d) { + return ctx.mkAnd(ctx.mkNot(ctx.mkFPIsZero(d)), applyUndefined(hasFractionFunc, d)); + } + + // Tracks d so that defineDoublesContradictedBy checks the model's value of func at d. + private Expr applyUndefined(FuncDecl func, FPExpr d) { + undefinedDoubles.add(d); + return ctx.mkApp(func, d); + } + + private BoolExpr defineDouble(FPExpr d) { + // 65-bit two's complement holds every truncation below 2^64. + IntExpr truncated = + ctx.mkBV2Int( + ctx.mkFPToBV(ctx.mkFPRoundTowardZero(), d, 65, /* signed= */ true), /* signed= */ true); + BoolExpr hasFraction = + ctx.mkNot(ctx.mkFPEq(d, ctx.mkFPRoundToIntegral(ctx.mkFPRoundTowardZero(), d))); + return ctx.mkImplies( + isBelowTwoTo64(d), + ctx.mkAnd( + ctx.mkEq(ctx.mkApp(truncateDoubleFunc, d), truncated), + ctx.mkEq(ctx.mkApp(hasFractionFunc, d), hasFraction))); + } + + // False for NaN and infinities. + private BoolExpr isBelowTwoTo64(FPExpr d) { + return ctx.mkFPLt(ctx.mkFPAbs(d), mkFpDouble(CelNumericBounds.TWO_TO_64)); + } + /** Safely concatenates two Z3 sequences. */ @SuppressWarnings("unchecked") // Callers verify arguments are SeqExprs. public SeqExpr mkConcatSafe(Expr arg1, Expr arg2) { @@ -956,6 +1087,11 @@ private static FuncDeclKey create(String name, Sort[] domain, Sort range) { this.hasTruncatedTypeConstraintFunc = ctx.mkFuncDecl( FUNC_HAS_TRUNCATED_TYPE_CONSTRAINT, new Sort[] {this.celValueSort}, ctx.getBoolSort()); + this.truncateDoubleFunc = + ctx.mkFuncDecl(FUNC_TRUNCATE_DOUBLE, ctx.mkFPSortDouble(), ctx.getIntSort()); + this.hasFractionFunc = + ctx.mkFuncDecl(FUNC_HAS_FRACTION, ctx.mkFPSortDouble(), ctx.getBoolSort()); + this.undefinedDoubles = new LinkedHashSet<>(); this.parameterizeUnknowns = parameterizeUnknowns; } } diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/AxiomHelpers.java b/verifier/src/main/java/dev/cel/verifier/axioms/AxiomHelpers.java index c7b101e21..a249b4fe9 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/AxiomHelpers.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/AxiomHelpers.java @@ -16,9 +16,7 @@ import com.microsoft.z3.BoolExpr; import com.microsoft.z3.Context; -import com.microsoft.z3.FPExpr; import com.microsoft.z3.IntExpr; -import com.microsoft.z3.RealExpr; /** Helper methods for Z3 axioms operations. */ final class AxiomHelpers { @@ -49,51 +47,5 @@ static IntExpr mkTruncatedMod(Context ctx, IntExpr a, IntExpr b) { return (IntExpr) ctx.mkSub(a, ctx.mkMul(mkTruncatedDiv(ctx, a, b), b)); } - /** - * Safe comparison between a Z3 Real (from int/uint) and a Z3 FloatingPoint (double) for {@code - * <}. - */ - static BoolExpr mkRealLtFp(Context ctx, RealExpr real, FPExpr fp) { - return mkSafeFpComparison(ctx, fp, isPosInf(ctx, fp), ctx.mkLt(real, ctx.mkFPToReal(fp))); - } - - /** - * Safe comparison between a Z3 FloatingPoint (double) and a Z3 Real (from int/uint) for {@code - * <}. - */ - static BoolExpr mkFpLtReal(Context ctx, FPExpr fp, RealExpr real) { - return mkSafeFpComparison(ctx, fp, isNegInf(ctx, fp), ctx.mkLt(ctx.mkFPToReal(fp), real)); - } - - /** - * Safe comparison between a Z3 Real (from int/uint) and a Z3 FloatingPoint (double) for {@code - * <=}. - */ - static BoolExpr mkRealLeFp(Context ctx, RealExpr real, FPExpr fp) { - return mkSafeFpComparison(ctx, fp, isPosInf(ctx, fp), ctx.mkLe(real, ctx.mkFPToReal(fp))); - } - - /** - * Safe comparison between a Z3 FloatingPoint (double) and a Z3 Real (from int/uint) for {@code - * <=}. - */ - static BoolExpr mkFpLeReal(Context ctx, FPExpr fp, RealExpr real) { - return mkSafeFpComparison(ctx, fp, isNegInf(ctx, fp), ctx.mkLe(ctx.mkFPToReal(fp), real)); - } - - private static BoolExpr isPosInf(Context ctx, FPExpr fp) { - return ctx.mkAnd(ctx.mkFPIsInfinite(fp), ctx.mkFPIsPositive(fp)); - } - - private static BoolExpr isNegInf(Context ctx, FPExpr fp) { - return ctx.mkAnd(ctx.mkFPIsInfinite(fp), ctx.mkFPIsNegative(fp)); - } - - private static BoolExpr mkSafeFpComparison( - Context ctx, FPExpr fp, BoolExpr infCondition, BoolExpr finiteComparison) { - BoolExpr isFinite = ctx.mkNot(ctx.mkOr(ctx.mkFPIsNaN(fp), ctx.mkFPIsInfinite(fp))); - return ctx.mkOr(infCondition, ctx.mkAnd(isFinite, finiteComparison)); - } - private AxiomHelpers() {} } diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/GreaterAxiom.java b/verifier/src/main/java/dev/cel/verifier/axioms/GreaterAxiom.java index 11c038bb0..913e3d15f 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/GreaterAxiom.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/GreaterAxiom.java @@ -86,37 +86,29 @@ final class GreaterAxiom { (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLtReal( - ctx, - typeSystem.getDouble(rhs), - ctx.mkInt2Real(typeSystem.getInt(lhs)))))) + typeSystem.doubleLtInt( + typeSystem.getDouble(rhs), typeSystem.getInt(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_UINT64_DOUBLE.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLtReal( - ctx, - typeSystem.getDouble(rhs), - ctx.mkInt2Real(typeSystem.getUint(lhs)))))) + typeSystem.doubleLtInt( + typeSystem.getDouble(rhs), typeSystem.getUint(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_DOUBLE_INT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLtFp( - ctx, - ctx.mkInt2Real(typeSystem.getInt(rhs)), - typeSystem.getDouble(lhs))))) + typeSystem.intLtDouble( + typeSystem.getInt(rhs), typeSystem.getDouble(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_DOUBLE_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLtFp( - ctx, - ctx.mkInt2Real(typeSystem.getUint(rhs)), - typeSystem.getDouble(lhs))))) + typeSystem.intLtDouble( + typeSystem.getUint(rhs), typeSystem.getDouble(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_INT64_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/GreaterEqualsAxiom.java b/verifier/src/main/java/dev/cel/verifier/axioms/GreaterEqualsAxiom.java index fad75bf3e..5d7a560ee 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/GreaterEqualsAxiom.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/GreaterEqualsAxiom.java @@ -86,37 +86,29 @@ final class GreaterEqualsAxiom { (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLeReal( - ctx, - typeSystem.getDouble(rhs), - ctx.mkInt2Real(typeSystem.getInt(lhs)))))) + typeSystem.doubleLeInt( + typeSystem.getDouble(rhs), typeSystem.getInt(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_EQUALS_UINT64_DOUBLE.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLeReal( - ctx, - typeSystem.getDouble(rhs), - ctx.mkInt2Real(typeSystem.getUint(lhs)))))) + typeSystem.doubleLeInt( + typeSystem.getDouble(rhs), typeSystem.getUint(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_EQUALS_DOUBLE_INT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLeFp( - ctx, - ctx.mkInt2Real(typeSystem.getInt(rhs)), - typeSystem.getDouble(lhs))))) + typeSystem.intLeDouble( + typeSystem.getInt(rhs), typeSystem.getDouble(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_EQUALS_DOUBLE_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLeFp( - ctx, - ctx.mkInt2Real(typeSystem.getUint(rhs)), - typeSystem.getDouble(lhs))))) + typeSystem.intLeDouble( + typeSystem.getUint(rhs), typeSystem.getDouble(lhs))))) .addBinaryOverloadTranslator( Comparison.GREATER_EQUALS_INT64_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/LessAxiom.java b/verifier/src/main/java/dev/cel/verifier/axioms/LessAxiom.java index 63dad8b58..59bf778a8 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/LessAxiom.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/LessAxiom.java @@ -86,37 +86,29 @@ final class LessAxiom { (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLtFp( - ctx, - ctx.mkInt2Real(typeSystem.getInt(lhs)), - typeSystem.getDouble(rhs))))) + typeSystem.intLtDouble( + typeSystem.getInt(lhs), typeSystem.getDouble(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_UINT64_DOUBLE.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLtFp( - ctx, - ctx.mkInt2Real(typeSystem.getUint(lhs)), - typeSystem.getDouble(rhs))))) + typeSystem.intLtDouble( + typeSystem.getUint(lhs), typeSystem.getDouble(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_DOUBLE_INT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLtReal( - ctx, - typeSystem.getDouble(lhs), - ctx.mkInt2Real(typeSystem.getInt(rhs)))))) + typeSystem.doubleLtInt( + typeSystem.getDouble(lhs), typeSystem.getInt(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_DOUBLE_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLtReal( - ctx, - typeSystem.getDouble(lhs), - ctx.mkInt2Real(typeSystem.getUint(rhs)))))) + typeSystem.doubleLtInt( + typeSystem.getDouble(lhs), typeSystem.getUint(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_INT64_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/LessEqualsAxiom.java b/verifier/src/main/java/dev/cel/verifier/axioms/LessEqualsAxiom.java index d5e5c24bb..e4fb1ac11 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/LessEqualsAxiom.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/LessEqualsAxiom.java @@ -86,37 +86,29 @@ final class LessEqualsAxiom { (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLeFp( - ctx, - ctx.mkInt2Real(typeSystem.getInt(lhs)), - typeSystem.getDouble(rhs))))) + typeSystem.intLeDouble( + typeSystem.getInt(lhs), typeSystem.getDouble(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_EQUALS_UINT64_DOUBLE.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkRealLeFp( - ctx, - ctx.mkInt2Real(typeSystem.getUint(lhs)), - typeSystem.getDouble(rhs))))) + typeSystem.intLeDouble( + typeSystem.getUint(lhs), typeSystem.getDouble(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_EQUALS_DOUBLE_INT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLeReal( - ctx, - typeSystem.getDouble(lhs), - ctx.mkInt2Real(typeSystem.getInt(rhs)))))) + typeSystem.doubleLeInt( + typeSystem.getDouble(lhs), typeSystem.getInt(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_EQUALS_DOUBLE_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> Optional.of( typeSystem.wrapBool( - AxiomHelpers.mkFpLeReal( - ctx, - typeSystem.getDouble(lhs), - ctx.mkInt2Real(typeSystem.getUint(rhs)))))) + typeSystem.doubleLeInt( + typeSystem.getDouble(lhs), typeSystem.getUint(rhs))))) .addBinaryOverloadTranslator( Comparison.LESS_EQUALS_INT64_UINT64.celOverloadDecl(), (ctx, typeSystem, constraintSink, lhs, rhs) -> diff --git a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java index a1d22081e..f92a4aa08 100644 --- a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java +++ b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java @@ -220,6 +220,12 @@ private enum IsSatisfiableTestCase { DURATION_SUBSECOND_SATISFIABLE( "dur == google.protobuf.Duration{seconds: 1, nanos: 500}", "dur = duration\\(\"1\\.000000500s\"\\)"), + // TODO: Drop the bound once CEL-Java finds uint keys of 2^63 or more by a double. + INTEGRAL_DOUBLE_MAP_KEY( + "d > 1.0 && d < 9223372036854775808.0 && dyn_int_map[d] == 1", "d = [1-9]"), + // An infinite double has no truncation, and the comparisons never need one. + INFINITE_DOUBLE_ABOVE_INT( + "x < d && d > 1.7976931348623157e308", "d = double\\(\"Infinity\"\\)"), // Timestamps and durations nested in dyn aren't range constrained. TIMESTAMP_ABOVE_RANGE_SATISFIABLE( "type(dyn_var) == google.protobuf.Timestamp" @@ -711,6 +717,8 @@ private enum IsSatisfiableInconclusiveTestCase { APPROXIMATED_INT_TO_STRING("string(123) == '123'"), APPROXIMATED_RANGE("int('123') > 100 && int('123') < 200"), APPROXIMATED_BRANCHING("int('123') == 123 ? x > 5 : false"), + // The exact pass refines its candidate away; its assertions mustn't leak into the next pass. + APPROXIMATED_AFTER_REFINEMENT("(dyn(x) == d && d == 1.5) || int(string_var) == 5"), APPROXIMATED_STRING_TO_INT_CONSTRAINED("string_var == 'abc' && int(string_var) == 5"), APPROXIMATED_STRING_TO_DOUBLE_NAN("double('NaN') != double('NaN')"), // int('x') errors at runtime, so type() of an approximate argument is approximate too. @@ -870,6 +878,19 @@ private enum IsUnsatisfiableTestCase { NON_BOOL_LOGICAL_OPERAND("dyn(1) && true"), ENUM_CONSTANTS_DISTINCT("TestAllTypes.NestedEnum.FOO == TestAllTypes.NestedEnum.BAR"), LEADING_DOT_GLOBAL_DISAMBIGUATION_CONTRADICTION("x == 5 && [1, 2].all(x, x > .x)"), + CROSS_TYPE_EQUAL_AND_LESS("dyn(x) == d && x < d"), + CROSS_TYPE_LESS_BOTH_WAYS("x < d && d < x"), + CROSS_TYPE_LESS_EQUALS_AND_GREATER("x <= d && d < x"), + CROSS_TYPE_INTEGRAL_BETWEEN_CONSECUTIVE_INTS("x < d && d < x + 1 && dyn(y) == d"), + // Runtimes round ints and uints to doubles, so this only holds for those that convert exactly. + CROSS_TYPE_EQUALITY_TRANSITIVE( + "-9007199254740992 <= x && x <= 9007199254740992 && u <= 9007199254740992u" + + " && dyn(x) == d && d == dyn(u) && dyn(x) != dyn(u)"), + CROSS_TYPE_OUT_OF_INT64_RANGE_DOUBLE_MAP_KEY( + "size(dyn_int_map) == 1 && dyn_int_map.all(k, type(k) == int)" + + " && dyn_int_map[9223372036854775808.0] == 1"), + CROSS_TYPE_FRACTIONAL_MAP_KEY( + "size(dyn_int_map) == 1 && d > 1.0 && d < 2.0 && dyn_int_map[d] == 1"), ; private final String expr; @@ -1183,6 +1204,14 @@ private enum IsAlwaysTrueTestCase { "unknown_var == 9223372036854775807 ? unknown_var != 1e100 : true"), HETEROGENEOUS_MAX_EXACT_INT("dyn(9007199254740992) == 9007199254740992.0"), HETEROGENEOUS_MIN_EXACT_INT("dyn(-9007199254740992) == -9007199254740992.0"), + HETEROGENEOUS_INT_BELOW_DOUBLE_ABOVE_TWO_TO_63("x < 9223372036854777856.0"), + HETEROGENEOUS_INT_AT_LEAST_MIN("x >= -9223372036854775808.0"), + HETEROGENEOUS_INT_ABOVE_MINUS_TWO_TO_64("x > -18446744073709551616.0"), + // Runtimes round u to a double, so this only holds for uints that convert exactly. + HETEROGENEOUS_UINT_BELOW_TWO_TO_64( + "u <= 9007199254740992u ? u < 18446744073709551616.0 : true"), + HETEROGENEOUS_ZERO_ORDERING("(x < 0.0) == (x < 0) && (x < -0.0) == (x < 0)"), + HETEROGENEOUS_SUBNORMAL_ORDERING("x > 0 ? dyn(x) > 4.9e-324 : dyn(x) < 4.9e-324"), HETEROGENEOUS_INT_PRECISION_LOSS_POS("dyn(9007199254740993) == 9007199254740992.0"), HETEROGENEOUS_INT_PRECISION_LOSS_NEG("dyn(-9007199254740993) == -9007199254740992.0"), HETEROGENEOUS_UINT_PRECISION_LOSS("dyn(9007199254740993u) == 9007199254740992.0"), @@ -2088,6 +2117,10 @@ private enum IsAlwaysTrueViolationTestCase { "Condition is not always true\\.", "Counterexample input:", "dyn_int_map = \\{1: 1\\}"), + CROSS_TYPE_POSITIVE_INT_EQUALS_DOUBLE("!(dyn(x) == d && x > 0)", "x = [1-9]\\d*", "d = [1-9]"), + CROSS_TYPE_NEGATIVE_DOUBLE_BETWEEN_INTS( + "!(x < 0 && x < d && d < x + 1)", "d = -\\d+\\.\\d*[1-9]"), + CROSS_TYPE_NAN_UNORDERED("dyn(x) < d || dyn(x) >= d", "d = double\\(\"NaN\"\\)"), ; private final String expr;