Constructor Detail

• KZ3ExprInternalizer

  KZ3ExprInternalizer(KContext ctx, KZ3Context z3InternCtx)

Method Detail

• getCtx

   final KContext getCtx()

• findInternalizedExpr

   Long findInternalizedExpr(KExpr<?> expr)

• saveInternalizedExpr

   Unit saveInternalizedExpr(KExpr<?> expr, Long internalized)

• internalizeDecl

   final <T extends KDecl<?>> Long internalizeDecl(T $self)

• internalizeSort

   final <T extends KSort> Long internalizeSort(T $self)

• transform

   <T extends KSort> KFunctionApp<T> transform(KFunctionApp<T> expr)

• transform

   <T extends KSort> KConst<T> transform(KConst<T> expr)

• transform

   KAndExpr transform(KAndExpr expr)

• transform

   KAndBinaryExpr transform(KAndBinaryExpr expr)

• transform

   KOrExpr transform(KOrExpr expr)

• transform

   KOrBinaryExpr transform(KOrBinaryExpr expr)

• transform

   KNotExpr transform(KNotExpr expr)

• transform

   KImpliesExpr transform(KImpliesExpr expr)

• transform

   KXorExpr transform(KXorExpr expr)

• transform

   KTrue transform(KTrue expr)

• transform

   KFalse transform(KFalse expr)

• transform

   <T extends KSort> KEqExpr<T> transform(KEqExpr<T> expr)

• transform

   <T extends KSort> KDistinctExpr<T> transform(KDistinctExpr<T> expr)

• transform

   <T extends KSort> KIteExpr<T> transform(KIteExpr<T> expr)

• transform

   KBitVecValue<KBv1Sort> transform(KBitVec1Value expr)

• transform

   KBitVecValue<KBv8Sort> transform(KBitVec8Value expr)

• transform

   KBitVecValue<KBv16Sort> transform(KBitVec16Value expr)

• transform

   KBitVecValue<KBv32Sort> transform(KBitVec32Value expr)

• transform

   KBitVecValue<KBv64Sort> transform(KBitVec64Value expr)

• transform

   KBitVecValue<KBvSort> transform(KBitVecCustomValue expr)

• transform

   <T extends KBvSort> KBvNotExpr<T> transform(KBvNotExpr<T> expr)

• transform

   <T extends KBvSort> KBvReductionAndExpr<T> transform(KBvReductionAndExpr<T> expr)

• transform

   <T extends KBvSort> KBvReductionOrExpr<T> transform(KBvReductionOrExpr<T> expr)

• transform

   <T extends KBvSort> KBvAndExpr<T> transform(KBvAndExpr<T> expr)

• transform

   <T extends KBvSort> KBvOrExpr<T> transform(KBvOrExpr<T> expr)

• transform

   <T extends KBvSort> KBvXorExpr<T> transform(KBvXorExpr<T> expr)

• transform

   <T extends KBvSort> KBvNAndExpr<T> transform(KBvNAndExpr<T> expr)

• transform

   <T extends KBvSort> KBvNorExpr<T> transform(KBvNorExpr<T> expr)

• transform

   <T extends KBvSort> KBvXNorExpr<T> transform(KBvXNorExpr<T> expr)

• transform

   <T extends KBvSort> KBvNegationExpr<T> transform(KBvNegationExpr<T> expr)

• transform

   <T extends KBvSort> KBvAddExpr<T> transform(KBvAddExpr<T> expr)

• transform

   <T extends KBvSort> KBvSubExpr<T> transform(KBvSubExpr<T> expr)

• transform

   <T extends KBvSort> KBvMulExpr<T> transform(KBvMulExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedDivExpr<T> transform(KBvUnsignedDivExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedDivExpr<T> transform(KBvSignedDivExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedRemExpr<T> transform(KBvUnsignedRemExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedRemExpr<T> transform(KBvSignedRemExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedModExpr<T> transform(KBvSignedModExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedLessExpr<T> transform(KBvUnsignedLessExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedLessExpr<T> transform(KBvSignedLessExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedLessOrEqualExpr<T> transform(KBvUnsignedLessOrEqualExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedLessOrEqualExpr<T> transform(KBvSignedLessOrEqualExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedGreaterOrEqualExpr<T> transform(KBvUnsignedGreaterOrEqualExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedGreaterOrEqualExpr<T> transform(KBvSignedGreaterOrEqualExpr<T> expr)

• transform

   <T extends KBvSort> KBvUnsignedGreaterExpr<T> transform(KBvUnsignedGreaterExpr<T> expr)

• transform

   <T extends KBvSort> KBvSignedGreaterExpr<T> transform(KBvSignedGreaterExpr<T> expr)

• transform

   KExpr<KBvSort> transform(KBvConcatExpr expr)

• transform

   KBvExtractExpr transform(KBvExtractExpr expr)

• transform

   KBvSignExtensionExpr transform(KBvSignExtensionExpr expr)

• transform

   KBvZeroExtensionExpr transform(KBvZeroExtensionExpr expr)

• transform

   KBvRepeatExpr transform(KBvRepeatExpr expr)

• transform

   <T extends KBvSort> KBvShiftLeftExpr<T> transform(KBvShiftLeftExpr<T> expr)

• transform

   <T extends KBvSort> KBvLogicalShiftRightExpr<T> transform(KBvLogicalShiftRightExpr<T> expr)

• transform

   <T extends KBvSort> KBvArithShiftRightExpr<T> transform(KBvArithShiftRightExpr<T> expr)

• transform

   <T extends KBvSort> KBvRotateLeftExpr<T> transform(KBvRotateLeftExpr<T> expr)

• transform

   <T extends KBvSort> KBvRotateLeftIndexedExpr<T> transform(KBvRotateLeftIndexedExpr<T> expr)

• transform

   <T extends KBvSort> KBvRotateRightExpr<T> transform(KBvRotateRightExpr<T> expr)

• transform

   <T extends KBvSort> KBvRotateRightIndexedExpr<T> transform(KBvRotateRightIndexedExpr<T> expr)

• transform

   KBv2IntExpr transform(KBv2IntExpr expr)

• transform

   <T extends KBvSort> KBvAddNoOverflowExpr<T> transform(KBvAddNoOverflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvAddNoUnderflowExpr<T> transform(KBvAddNoUnderflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvSubNoOverflowExpr<T> transform(KBvSubNoOverflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvSubNoUnderflowExpr<T> transform(KBvSubNoUnderflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvDivNoOverflowExpr<T> transform(KBvDivNoOverflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvNegNoOverflowExpr<T> transform(KBvNegNoOverflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvMulNoOverflowExpr<T> transform(KBvMulNoOverflowExpr<T> expr)

• transform

   <T extends KBvSort> KBvMulNoUnderflowExpr<T> transform(KBvMulNoUnderflowExpr<T> expr)

• transform

   KExpr<KFp16Sort> transform(KFp16Value expr)

• transform

   KExpr<KFp32Sort> transform(KFp32Value expr)

• transform

   KExpr<KFp64Sort> transform(KFp64Value expr)

• transform

   KExpr<KFp128Sort> transform(KFp128Value expr)

• transform

   KExpr<KFpSort> transform(KFpCustomSizeValue expr)

• transform

   KExpr<KFpRoundingModeSort> transform(KFpRoundingModeExpr expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpAbsExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpNegationExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpAddExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpSubExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpMulExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpDivExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpFusedMulAddExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpSqrtExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpRemExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpRoundToIntegralExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpMinExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpMaxExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpLessOrEqualExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpLessExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpGreaterOrEqualExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpGreaterExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpEqualExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsNormalExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsSubnormalExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsZeroExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsInfiniteExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsNaNExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsNegativeExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBoolSort> transform(KFpIsPositiveExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBvSort> transform(KFpToBvExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KRealSort> transform(KFpToRealExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<KBvSort> transform(KFpToIEEEBvExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpFromBvExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KFpToFpExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KRealToFpExpr<T> expr)

• transform

   <T extends KFpSort> KExpr<T> transform(KBvToFpExpr<T> expr)

• transform

   <D extends KSort, R extends KSort> KArrayStore<D, R> transform(KArrayStore<D, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, R extends KSort> KExpr<KArray2Sort<D0, D1, R>> transform(KArray2Store<D0, D1, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, D2 extends KSort, R extends KSort> KExpr<KArray3Sort<D0, D1, D2, R>> transform(KArray3Store<D0, D1, D2, R> expr)

• transform

   <R extends KSort> KExpr<KArrayNSort<R>> transform(KArrayNStore<R> expr)

• transform

   <D extends KSort, R extends KSort> KArraySelect<D, R> transform(KArraySelect<D, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, R extends KSort> KExpr<R> transform(KArray2Select<D0, D1, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, D2 extends KSort, R extends KSort> KExpr<R> transform(KArray3Select<D0, D1, D2, R> expr)

• transform

   <R extends KSort> KExpr<R> transform(KArrayNSelect<R> expr)

• transform

   <A extends KArraySortBase<R>, R extends KSort> KArrayConst<A, R> transform(KArrayConst<A, R> expr)

• transform

   <D extends KSort, R extends KSort> KArrayLambda<D, R> transform(KArrayLambda<D, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, R extends KSort> KExpr<KArray2Sort<D0, D1, R>> transform(KArray2Lambda<D0, D1, R> expr)

• transform

   <D0 extends KSort, D1 extends KSort, D2 extends KSort, R extends KSort> KExpr<KArray3Sort<D0, D1, D2, R>> transform(KArray3Lambda<D0, D1, D2, R> expr)

• transform

   <R extends KSort> KExpr<KArrayNSort<R>> transform(KArrayNLambda<R> expr)

• transform

   <T extends KArithSort> KAddArithExpr<T> transform(KAddArithExpr<T> expr)

• transform

   <T extends KArithSort> KSubArithExpr<T> transform(KSubArithExpr<T> expr)

• transform

   <T extends KArithSort> KMulArithExpr<T> transform(KMulArithExpr<T> expr)

• transform

   <T extends KArithSort> KUnaryMinusArithExpr<T> transform(KUnaryMinusArithExpr<T> expr)

• transform

   <T extends KArithSort> KDivArithExpr<T> transform(KDivArithExpr<T> expr)

• transform

   <T extends KArithSort> KPowerArithExpr<T> transform(KPowerArithExpr<T> expr)

• transform

   <T extends KArithSort> KLtArithExpr<T> transform(KLtArithExpr<T> expr)

• transform

   <T extends KArithSort> KLeArithExpr<T> transform(KLeArithExpr<T> expr)

• transform

   <T extends KArithSort> KGtArithExpr<T> transform(KGtArithExpr<T> expr)

• transform

   <T extends KArithSort> KGeArithExpr<T> transform(KGeArithExpr<T> expr)

• transform

   KModIntExpr transform(KModIntExpr expr)

• transform

   KRemIntExpr transform(KRemIntExpr expr)

• transform

   KToRealIntExpr transform(KToRealIntExpr expr)

• transform

   KInt32NumExpr transform(KInt32NumExpr expr)

• transform

   KInt64NumExpr transform(KInt64NumExpr expr)

• transform

   KIntBigNumExpr transform(KIntBigNumExpr expr)

• transform

   KToIntRealExpr transform(KToIntRealExpr expr)

• transform

   KIsIntRealExpr transform(KIsIntRealExpr expr)

• transform

   KRealNumExpr transform(KRealNumExpr expr)

• transform

   KQuantifier transform(KExistentialQuantifier expr)

• transform

   KQuantifier transform(KUniversalQuantifier expr)

• transform

   <A extends KArraySortBase<R>, R extends KSort> KExpr<A> transform(KFunctionAsArray<A, R> expr)

• transform

   KExpr<KUninterpretedSort> transform(KUninterpretedSortValue expr)

  There is no way in Z3 API to mark uninterpreted constant as value.

  To overcome this we apply the following scheme:

  • Internalize value x of a sort T as normal constant.

  • Associate unique interpreted value i with this constant. Currently, we use integer values.

  • Introduce interpreter function F of type T -> Int. We introduce one function for each uninterpreted sort.

  • Assert expression (= i (F x)) to the solver. Since all Int values are known to be distinct, this assertion forces that all values of T are also distinct.

• transform

   final <S extends KExpr<?>> S transform(S $self, KExpr<?> arg, Function2<Long, Long, Long> operation)

• transform

   final <S extends KExpr<?>> S transform(S $self, KExpr<?> arg0, KExpr<?> arg1, Function3<Long, Long, Long, Long> operation)

• transform

   final <S extends KExpr<?>> S transform(S $self, KExpr<?> arg0, KExpr<?> arg1, KExpr<?> arg2, Function4<Long, Long, Long, Long, Long> operation)

• transform

   final <S extends KExpr<?>> S transform(S $self, KExpr<?> arg0, KExpr<?> arg1, KExpr<?> arg2, KExpr<?> arg3, Function5<Long, Long, Long, Long, Long, Long> operation)

• transformBitVecValue

   final <T extends KBvSort> KBitVecValue<T> transformBitVecValue(KBitVecValue<T> expr)

• transformArray

   final <S extends KExpr<?>> S transformArray(S $self, List<KExpr<?>> args, Function1<LongArray, Long> operation)