arrow-analysis-common/arrow.meta.plugins.analysis.smt/Solver

Solver

class Solver(context: SolverContext, nameProvider: NameProvider) : SolverContext, FormulaManager, BooleanFormulaManager, KotlinPrinter

Types

Companion

object Companion

Functions

and

open override fun and(vararg p0: BooleanFormula): BooleanFormula

open override fun and(p0: MutableCollection<BooleanFormula>): BooleanFormula

open override fun and(p0: BooleanFormula, p1: BooleanFormula): BooleanFormula

applyTactic

open override fun applyTactic(p0: BooleanFormula, p1: Tactic): BooleanFormula

arrays

fun <A> arrays(f: ArrayFormulaManager.() -> A): A

bitvectors

fun <A> bitvectors(f: BitvectorFormulaManager.() -> A): A

booleans

fun <A> booleans(f: BooleanFormulaManager.() -> A): A

boolValue

fun boolValue(formula: ObjectFormula): BooleanFormula

open override fun close()

decimalValue

fun decimalValue(formula: ObjectFormula): NumeralFormula.RationalFormula

dumpFormula

open override fun dumpFormula(p0: BooleanFormula): Appender

dumpKotlinLike

open override fun List<Formula>.dumpKotlinLike(): String

open override fun Formula.dumpKotlinLike(): String

dumpKotlinLikeOrRemove

open override fun Formula.dumpKotlinLikeOrRemove(): String?

equivalence

open override fun equivalence(p0: BooleanFormula, p1: BooleanFormula): BooleanFormula

escape

open override fun escape(p0: String): String

extractVariables

open override fun extractVariables(p0: Formula): MutableMap<String, Formula>

extractVariablesAndUFs

open override fun extractVariablesAndUFs(p0: Formula): MutableMap<String, Formula>

field

fun field(fieldName: String, formula: ObjectFormula): ObjectFormula

floatingPoint

fun <A> floatingPoint(f: FloatingPointFormulaManager.() -> A): A

formulae

fun <A> formulae(f: FormulaManager.() -> A): A

getArrayFormulaManager

open override fun getArrayFormulaManager(): ArrayFormulaManager

getBitvectorFormulaManager

open override fun getBitvectorFormulaManager(): BitvectorFormulaManager

getBooleanFormulaManager

open override fun getBooleanFormulaManager(): BooleanFormulaManager

getFloatingPointFormulaManager

open override fun getFloatingPointFormulaManager(): FloatingPointFormulaManager

getFormulaManager

open override fun getFormulaManager(): FormulaManager

getFormulaType

open override fun <T : Formula> getFormulaType(p0: T): FormulaType<T>

getIntegerFormulaManager

open override fun getIntegerFormulaManager(): IntegerFormulaManager

getQuantifiedFormulaManager

open override fun getQuantifiedFormulaManager(): QuantifiedFormulaManager

getRationalFormulaManager

open override fun getRationalFormulaManager(): RationalFormulaManager

getSLFormulaManager

open override fun getSLFormulaManager(): SLFormulaManager

getSolverName

open override fun getSolverName(): SolverContextFactory.Solvers

getUFManager

open override fun getUFManager(): UFManager

getVersion

open override fun getVersion(): String

ifThenElse

open override fun <T : Formula> ifThenElse(p0: BooleanFormula, p1: T, p2: T): T

implication

open override fun implication(p0: BooleanFormula, p1: BooleanFormula): BooleanFormula

ints

fun <A> ints(f: IntegerFormulaManager.() -> A): A

intValue

fun intValue(formula: ObjectFormula): NumeralFormula.IntegerFormula

isFalse

open override fun isFalse(p0: BooleanFormula): Boolean

isNotNull

fun isNotNull(formula: ObjectFormula): BooleanFormula

isNull

fun isNull(formula: ObjectFormula): BooleanFormula

isTrue

open override fun isTrue(p0: BooleanFormula): Boolean

isValidName

open override fun isValidName(p0: String): Boolean

makeApplication

open override fun <T : Formula> makeApplication(p0: FunctionDeclaration<T>, vararg p1: Formula): T

open override fun <T : Formula> makeApplication(p0: FunctionDeclaration<T>, p1: MutableList<out Formula>): T

makeBoolean

open fun makeBoolean(p0: Boolean): BooleanFormula

makeBooleanObjectVariable

fun makeBooleanObjectVariable(varName: String): BooleanFormula

makeDecimalObjectVariable

fun makeDecimalObjectVariable(varName: String): NumeralFormula.RationalFormula

makeFalse

open override fun makeFalse(): BooleanFormula

makeIntegerObjectVariable

fun makeIntegerObjectVariable(varName: String): NumeralFormula.IntegerFormula

makeObjectVariable

fun makeObjectVariable(varName: String): ObjectFormula

makeTrue

open override fun makeTrue(): BooleanFormula

makeVariable

open override fun makeVariable(p0: String): BooleanFormula

open override fun <T : Formula> makeVariable(p0: FormulaType<T>, p1: String): T

mirroredElement

open override fun mirroredElement(name: String): ReferencedElement?

newOptimizationProverEnvironment

open override fun newOptimizationProverEnvironment(vararg p0: SolverContext.ProverOptions): OptimizationProverEnvironment

newProverEnvironment

open override fun newProverEnvironment(vararg p0: SolverContext.ProverOptions): ProverEnvironment

newProverEnvironmentWithInterpolation

open override fun newProverEnvironmentWithInterpolation(vararg p0: SolverContext.ProverOptions): InterpolatingProverEnvironment<*>

not

open override fun not(p0: BooleanFormula): BooleanFormula

objects

fun <A> objects(f: IntegerFormulaManager.() -> A): A

open override fun or(vararg p0: BooleanFormula): BooleanFormula

open override fun or(p0: MutableCollection<BooleanFormula>): BooleanFormula

open override fun or(p0: BooleanFormula, p1: BooleanFormula): BooleanFormula

parse

open override fun parse(p0: String): BooleanFormula

quantified

fun <A> quantified(f: QuantifiedFormulaManager.() -> A): A

rationals

fun <A> rationals(f: RationalFormulaManager.() -> A): A

separationLogic

fun <A> separationLogic(f: SLFormulaManager.() -> A): A

simplify

open override fun <T : Formula> simplify(p0: T): T

substitute

open override fun <T : Formula> substitute(p0: T, p1: MutableMap<out Formula, out Formula>): T

toConjunction

open override fun toConjunction(): Collector<BooleanFormula, *, BooleanFormula>

toConjunctionArgs

open override fun toConjunctionArgs(p0: BooleanFormula, p1: Boolean): MutableSet<BooleanFormula>

toDisjunction

open override fun toDisjunction(): Collector<BooleanFormula, *, BooleanFormula>

toDisjunctionArgs

open override fun toDisjunctionArgs(p0: BooleanFormula, p1: Boolean): MutableSet<BooleanFormula>

transformRecursively

open override fun transformRecursively(p0: BooleanFormula, p1: BooleanFormulaTransformationVisitor): BooleanFormula

open override fun <T : Formula> transformRecursively(p0: T, p1: FormulaTransformationVisitor): T

translateFrom

open override fun translateFrom(p0: BooleanFormula, p1: FormulaManager): BooleanFormula

unescape

open override fun unescape(p0: String): String

uninterpretedFunctions

fun <A> uninterpretedFunctions(f: UFManager.() -> A): A

visit

@CanIgnoreReturnValue

open override fun <R : Any> visit(p0: BooleanFormula, p1: BooleanFormulaVisitor<R>): R

@CanIgnoreReturnValue

open override fun <R : Any> visit(p0: Formula, p1: FormulaVisitor<R>): R

visitRecursively

open override fun visitRecursively(p0: BooleanFormula, p1: BooleanFormulaVisitor<TraversalProcess>)

open override fun visitRecursively(p0: Formula, p1: FormulaVisitor<TraversalProcess>)

xor

open override fun xor(p0: BooleanFormula, p1: BooleanFormula): BooleanFormula

Properties

boolValueFun

val boolValueFun: FunctionDeclaration<BooleanFormula>

decimalValueFun

val decimalValueFun: FunctionDeclaration<NumeralFormula.RationalFormula>

fieldFun

val fieldFun: FunctionDeclaration<ObjectFormula>

intValueFun

val intValueFun: FunctionDeclaration<ObjectFormula>

isNullFn

val isNullFn: FunctionDeclaration<BooleanFormula>

resultVariable

val resultVariable: NumeralFormula.IntegerFormula

thisVariable

val thisVariable: NumeralFormula.IntegerFormula

Extensions

isFieldCall

fun Solver.isFieldCall(f: Formula): Boolean

primitiveFormula

fun Solver.primitiveFormula(context: ResolutionContext, resolvedCall: ResolvedCall, args: List<Formula>): Formula?

renameDeclarationConstraints

fun Solver.renameDeclarationConstraints(decl: DeclarationConstraints, mapping: Map<String, String>): DeclarationConstraints

substituteDeclarationConstraints

fun Solver.substituteDeclarationConstraints(decl: DeclarationConstraints, mapping: Map<String, ObjectFormula>): DeclarationConstraints

substituteVariable

fun <T : Formula> Solver.substituteVariable(formula: T, mapping: Map<String, Formula>): T