templates

Type Members

case class App(caller: Encoded, tpe: ast.Trees.FunctionType, args: Seq[Arg], encoded: Encoded) extends Product with Serializable

Represents an application of a first-class function in the unfolding procedure
Represents an application of a first-class function in the unfolding procedure

Definition Classes
Templates
type Apps = Map[Encoded, Set[App]]

Definition Classes
Templates
type Arg = Either[Encoded, Matcher]

Definition Classes
Templates
implicit class ArgWrapper extends AnyRef

Definition Classes
Templates
case class Call(tfd: ast.Trees.TypedFunDef, args: Seq[Arg], tpSubst: Seq[Arg]) extends Product with Serializable

Represents a named function call in the unfolding procedure
Represents a named function call in the unfolding procedure

Definition Classes
Templates
type Calls = Map[Encoded, Set[Call]]

Definition Classes
Templates
case class Capture(encoded: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TemplateInstantiator with Product with Serializable

Definition Classes
TypeTemplates
case class CaptureGenerator(container: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
class CaptureTemplate extends Template

Template used to unfold ADT closures that may contain functions.
Template used to unfold ADT closures that may contain functions.

Definition Classes
TypeTemplates
type Clauses = Seq[Encoded]

Abstract templates
Abstract templates
Pre-compiled sets of clauses with extra bookkeeping information that enables efficient unfolding of function calls and applications. Template is a super-type for all such clause sets that can be instantiated given a concrete argument list and a blocker in the decision-tree.

Definition Classes
Templates
implicit class ClausesWrapper extends AnyRef

Attributes
protected
Definition Classes
TemplateGenerator
case class Constraint(result: Encoded, closures: Seq[Arg], free: Boolean) extends Templates.TemplateInstantiator with Product with Serializable

Definition Classes
TypeTemplates
class ConstraintTemplate extends Template

Template used to unfold free symbols in the input expression.
Template used to unfold free symbols in the input expression.

Definition Classes
TypeTemplates
type Encoded = IExpression

Definition Classes
templates → Templates
type Equalities = Map[Encoded, Set[Equality]]

Definition Classes
Templates
case class Equality(tpe: ast.Trees.Type, e1: Encoded, e2: Encoded) extends Product with Serializable

Represents an equality relation between two instances of a given type
Represents an equality relation between two instances of a given type

Definition Classes
Templates
class EqualityTemplate extends Template

Definition Classes
EqualityTemplates
class FunctionTemplate extends Template

Definition Classes
FunctionTemplates
class LambdaTemplate extends Template

Definition Classes
LambdaTemplates
trait Manager extends IncrementalStateWrapper

Definition Classes
Templates
implicit class MapSeqWrapper[A, B] extends AnyRef

Definition Classes
Templates
implicit class MapSetWrapper[A, B] extends AnyRef

Template instantiations
Template instantiations
Template instances, when provided with concrete arguments and a blocker, will generate three outputs used for program unfolding: - clauses: clauses that will be added to the underlying solver - call blockers: bookkeeping information necessary for named function unfolding - app blockers: bookkeeping information necessary for first-class function unfolding
This object provides helper methods to deal with the triplets generated during unfolding.

Definition Classes
Templates
case class Matcher(key: Either[(Encoded, ast.Trees.Type), ast.Trees.TypedFunDef], args: Seq[Arg], encoded: Encoded) extends Product with Serializable

Represents an E-matching matcher that will be used to instantiate relevant quantified propositions
Represents an E-matching matcher that will be used to instantiate relevant quantified propositions

Definition Classes
Templates
type Matchers = Map[Encoded, Set[Matcher]]

Definition Classes
Templates
case class Negative(insts: (ast.Trees.Variable, Encoded)) extends Templates.Polarity with Product with Serializable

Definition Classes
QuantificationTemplates
type Pointers = Map[Encoded, Encoded]

Definition Classes
Templates
sealed abstract class Polarity extends AnyRef

Represents the polarity of the quantification within the considered formula.
Represents the polarity of the quantification within the considered formula. Positive and negative polarity enable optimizations during quantifier instantiation.

Definition Classes
QuantificationTemplates
case class Positive(subst: Map[ast.Trees.Variable, Arg]) extends Templates.Polarity with Product with Serializable

Definition Classes
QuantificationTemplates
class QuantificationTemplate extends AnyRef

Definition Classes
QuantificationTemplates
trait Template extends AnyRef

Definition Classes
Templates
case class TemplateAppInfo(template: Either[Templates.LambdaTemplate, Encoded], equals: Encoded, args: Seq[Arg]) extends Product with Serializable

Represents a POTENTIAL application of a first-class function in the unfolding procedure
Represents a POTENTIAL application of a first-class function in the unfolding procedure
The equals condition guards the application for equality of the concrete caller with the provided template in order to perform dynamic dispatch.

Definition Classes
LambdaTemplates
type TemplateClauses = (Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Set[ast.Trees.Variable]], Map[ast.Trees.Variable, Seq[ast.Trees.Expr]], Seq[ast.Trees.Expr], Types, Equalities, Seq[LambdaTemplate], Seq[QuantificationTemplate])

Attributes
protected
Definition Classes
TemplateGenerator
case class TemplateContents(pathVar: (ast.Trees.Variable, Encoded), arguments: Seq[(ast.Trees.Variable, Encoded)], condVars: Map[ast.Trees.Variable, Encoded], exprVars: Map[ast.Trees.Variable, Encoded], condTree: Map[ast.Trees.Variable, Set[ast.Trees.Variable]], clauses: Clauses, types: Types, blockers: Calls, applications: Apps, matchers: Matchers, equalities: Equalities, lambdas: Seq[Templates.LambdaTemplate], quantifications: Seq[Templates.QuantificationTemplate], pointers: Pointers) extends Product with Serializable

Definition Classes
Templates
sealed abstract class TemplateInstantiator extends AnyRef

Represents the kind of instantiator (@see ConstraintTemplate and CaptureTemplate) a given template info is associated to.
Represents the kind of instantiator (@see ConstraintTemplate and CaptureTemplate) a given template info is associated to.

Definition Classes
TypeTemplates
class TemplateStructure extends AnyRef

Semi-template used for inner-template equality
Semi-template used for inner-template equality
We introduce a structure here that resembles a Template that is instantiated ONCE when the corresponding template becomes of interest.

Definition Classes
Templates
sealed abstract class TypeUnrolling extends AnyRef

Determines whether a given type should be unrolled, depending on the kind of type unrolling, namely free variable type unrolling (dependent types and ADT invariants), contract type unrolling (dependent types), and capture unrolling (function closure ordering).
Determines whether a given type should be unrolled, depending on the kind of type unrolling, namely free variable type unrolling (dependent types and ADT invariants), contract type unrolling (dependent types), and capture unrolling (function closure ordering).

Attributes
protected
Definition Classes
TypeTemplates
type Types = Map[Encoded, Set[Typing]]

Definition Classes
Templates
case class Typing(tpe: ast.Trees.Type, arg: Encoded, instantiator: Templates.TemplateInstantiator) extends Product with Serializable

Represents a type unfolding of a free variable (or input) in the unfolding procedure
Represents a type unfolding of a free variable (or input) in the unfolding procedure

Definition Classes
TypeTemplates
sealed abstract class TypingGenerator extends AnyRef

Attributes
protected
Definition Classes
TypeTemplates

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object CaptureTemplate

Template generator for CaptureTemplate instances.
Template generator for CaptureTemplate instances.

Definition Classes
TypeTemplates
object CaptureUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object ConstraintTemplate

Generator for ConstraintTemplate instances.
Generator for ConstraintTemplate instances.

Definition Classes
TypeTemplates
object ContractGenerator extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object ContractUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object EqualityTemplate

Definition Classes
EqualityTemplates
object FreeGenerator extends Templates.TypingGenerator with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object FreeUnrolling extends Templates.TypeUnrolling with Product with Serializable

Attributes
protected
Definition Classes
TypeTemplates
object FunctionMatcher

Definition Classes
QuantificationTemplates
object FunctionTemplate

Definition Classes
FunctionTemplates
object LambdaTemplate

Constructor object for LambdaTemplate
Constructor object for LambdaTemplate
The apply methods performs some pre-processing before creating an instance of LambdaTemplate.

Definition Classes
LambdaTemplates
object QuantificationMatcher

Definition Classes
QuantificationTemplates
object QuantificationTemplate

Definition Classes
QuantificationTemplates
object Template

Definition Classes
Templates
object TemplateAppInfo extends Serializable

Definition Classes
LambdaTemplates
object TemplateContents extends Serializable

Definition Classes
Templates
def abort: Boolean

Definition Classes
templates → Templates
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asString(ast: IExpression): String

Definition Classes
templates → Templates
def blockerChildren(b: Encoded, strict: Boolean = true): Set[Encoded]

Attributes
protected
Definition Classes
Templates
def blockerEquals(b: Encoded): Set[Encoded]

Attributes
protected
Definition Classes
Templates
def blockerParents(b: Encoded, strict: Boolean = true): Set[Encoded]

Attributes
protected
Definition Classes
Templates
def blockerPath(bs: Set[Encoded]): Set[Encoded]

Attributes
protected
Definition Classes
Templates
def blockerPath(b: Encoded): Set[Encoded]

Attributes
protected
Definition Classes
Templates
def canUnroll: Boolean

Definition Classes
Templates
def clear(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val context: Context

Definition Classes
templates → Templates
def correspond(m1: Matcher, m2: Matcher): Option[Boolean]

Attributes
protected
Definition Classes
QuantificationTemplates
Annotations
@inline()
def correspond(k1: MatcherKey, k2: MatcherKey): Option[Boolean]

Attributes
protected
Definition Classes
QuantificationTemplates
def currentGeneration: Int

Attributes
protected
Definition Classes
Templates
implicit val debugSection: DebugSectionSolver.type

Definition Classes
Templates
def decodePartial(e: Encoded, tpe: ast.Trees.Type): Option[ast.Trees.Expr]

Definition Classes
templates → Templates
lazy val deferFactor: Int

Attributes
protected
Definition Classes
Templates
def emptyClauses: TemplateClauses

Attributes
protected
Definition Classes
TemplateGenerator
def encodeBlockers(bs: Set[Encoded]): (Encoded, Clauses)

Attributes
protected
Definition Classes
Templates
def encodeSymbol(v: ast.Trees.Variable): IExpression

Definition Classes
templates → Templates
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalitySymbol(tpe: ast.Trees.Type): (ast.Trees.Variable, Encoded)

Definition Classes
EqualityTemplates
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def extractNot(e: IExpression): Option[Encoded]

Definition Classes
templates → Templates
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def freshConds(pathVar: Encoded, condVars: Map[ast.Trees.Variable, Encoded], tree: Map[ast.Trees.Variable, Set[ast.Trees.Variable]]): Map[Encoded, Encoded]

Attributes
protected
Definition Classes
Templates
def getAxioms: Seq[Axiom]

Definition Classes
QuantificationTemplates
def getCalls: Seq[(Encoded, Call)]

Definition Classes
FunctionTemplates
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getFiniteRangeClauses: Clauses

Definition Classes
QuantificationTemplates
def getGroundInstantiations(e: Encoded, tpe: ast.Trees.Type): Seq[(Encoded, Seq[Encoded])]

Definition Classes
QuantificationTemplates
def getInstantiationsWithBlockers: Seq[(Encoded, Set[Encoded])]

Definition Classes
QuantificationTemplates
def getLambdaTemplates(tpe: ast.Trees.FunctionType): Set[LambdaTemplate]

Definition Classes
LambdaTemplates
def hasAxioms: Boolean

Definition Classes
QuantificationTemplates
def hashCode(): Int

Definition Classes
AnyRef → Any
val incrementals: Seq[IncrementalState]

Definition Classes
Templates → IncrementalStateWrapper
def instantiateApp(blocker: Encoded, app: App): Clauses

Definition Classes
LambdaTemplates
def instantiateCall(blocker: Encoded, fi: Call): Clauses

Definition Classes
FunctionTemplates
def instantiateEquality(blocker: Encoded, equality: Equality): Clauses

Definition Classes
EqualityTemplates
def instantiateExpr(expr: ast.Trees.Expr, bindings: Map[ast.Trees.Variable, Encoded]): Clauses

Definition Classes
Templates
def instantiateLambda(template: LambdaTemplate): (Encoded, Clauses)

Definition Classes
LambdaTemplates
def instantiateMatcher(blocker: Encoded, matcher: Matcher): Clauses

Definition Classes
QuantificationTemplates
def instantiateQuantification(template: QuantificationTemplate): (Map[Encoded, Encoded], Clauses)

Definition Classes
QuantificationTemplates
def instantiateType(blocker: Encoded, typing: Typing): Clauses

Definition Classes
TypeTemplates
def instantiateVariable(v: ast.Trees.Variable, bindings: Map[ast.Trees.Variable, Encoded]): Clauses

Definition Classes
Templates
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mkAnd(es: IExpression*): IExpression

Definition Classes
templates → Templates
def mkClauses(pathVar: ast.Trees.Variable, tpe: ast.Trees.Type, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded])(implicit generator: TypingGenerator): TemplateClauses

Definition Classes
TemplateGenerator
def mkClauses(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], polarity: Option[Boolean] = None): TemplateClauses

Definition Classes
TemplateGenerator
def mkEncoder(bindings: Map[ast.Trees.Variable, IExpression])(e: ast.Trees.Expr): IExpression

Definition Classes
templates → Templates
def mkEquals(e1: IExpression, e2: IExpression): Encoded

Definition Classes
templates → Templates
def mkExprClauses(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], polarity: Option[Boolean] = None): (ast.Trees.Expr, TemplateClauses)

Attributes
protected
Definition Classes
TemplateGenerator
def mkExprStructure(pathVar: ast.Trees.Variable, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded], onlySimple: Boolean = false): (ast.Trees.Expr, TemplateStructure, Map[ast.Trees.Variable, Encoded])

Attributes
protected
Definition Classes
TemplateGenerator
def mkImplies(e1: IExpression, e2: IExpression): IFormula

Definition Classes
templates → Templates
def mkNot(e: IExpression): IFormula

Definition Classes
templates → Templates
def mkOr(es: IExpression*): IExpression

Definition Classes
templates → Templates
def mkSubstituter(substMap: Map[IExpression, IExpression]): (IExpression) ⇒ IExpression

Definition Classes
templates → Templates
def mkTypeClauses(pathVar: ast.Trees.Variable, tpe: ast.Trees.Type, expr: ast.Trees.Expr, substMap: Map[ast.Trees.Variable, Encoded])(implicit generator: TypingGenerator): (ast.Trees.Expr, TemplateClauses)

Generates the clauses and other bookkeeping relevant to a type unfolding template.
Generates the clauses and other bookkeeping relevant to a type unfolding template.

Attributes
protected
Definition Classes
TemplateGenerator
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nextGeneration(gen: Int): Int

Attributes
protected
Definition Classes
Templates
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pause: Boolean

Definition Classes
templates → Templates
def pop(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
final def pop(lvl: Int): Unit

Definition Classes
IncrementalState
val program: PrincessSolver.targetProgram

Definition Classes
templates → Templates
def promoteBlocker(b: Encoded, force: Boolean = false): Boolean

Definition Classes
Templates
def promoteQuantifications: Unit

Definition Classes
QuantificationTemplates
def push(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def refutationAssumptions: Seq[Encoded]

Definition Classes
Templates
def registerClosure(start: Encoded, container: (Encoded, ast.Trees.FunctionType), arg: (Encoded, ast.Trees.Type)): Clauses

Sets up the relevant unfolding procedure for closure ordering
Sets up the relevant unfolding procedure for closure ordering

Definition Classes
TypeTemplates
def registerEquality(blocker: Encoded, equality: Equality): Encoded

Definition Classes
EqualityTemplates
def registerEquality(blocker: Encoded, tpe: ast.Trees.Type, e1: Encoded, e2: Encoded): Encoded

Definition Classes
EqualityTemplates
def registerFunction(b: Encoded, r: Encoded, tpe: ast.Trees.Type, f: Encoded, closures: Seq[Arg], free: Boolean): Clauses

Definition Classes
LambdaTemplates
def registerImplication(b1: Encoded, b2: Encoded): Unit

Attributes
protected
Definition Classes
Templates
def registerLambda(pointer: Encoded, target: Encoded): Boolean

Definition Classes
LambdaTemplates
def requiresFiniteRangeCheck: Boolean

Definition Classes
QuantificationTemplates
def reset(): Unit

Definition Classes
IncrementalStateWrapper → IncrementalState
def satisfactionAssumptions: Seq[Encoded]

Definition Classes
Templates
val semantics: (PrincessSolver.targetProgram)#Semantics

Definition Classes
templates → Templates
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unroll: Clauses

Definition Classes
Templates
def unrollEquality(tpe: ast.Trees.Type): Boolean

Definition Classes
EqualityTemplates
def variableSeq(tpe: ast.Trees.Type): Seq[ast.Trees.Variable]

Attributes
protected
Definition Classes
FunctionTemplates
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package PrincessSolver

object templates extends Templates

Type Members

case class App(caller: Encoded, tpe: ast.Trees.FunctionType, args: Seq[Arg], encoded: Encoded) extends Product with Serializable

type Apps = Map[Encoded, Set[App]]

type Arg = Either[Encoded, Matcher]

implicit class ArgWrapper extends AnyRef

case class Call(tfd: ast.Trees.TypedFunDef, args: Seq[Arg], tpSubst: Seq[Arg]) extends Product with Serializable

type Calls = Map[Encoded, Set[Call]]

case class Capture(encoded: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TemplateInstantiator with Product with Serializable

case class CaptureGenerator(container: Encoded, tpe: ast.Trees.FunctionType) extends Templates.TypingGenerator with Product with Serializable

class CaptureTemplate extends Template

type Clauses = Seq[Encoded]

implicit class ClausesWrapper extends AnyRef

case class Constraint(result: Encoded, closures: Seq[Arg], free: Boolean) extends Templates.TemplateInstantiator with Product with Serializable

class ConstraintTemplate extends Template

type Encoded = IExpression

type Equalities = Map[Encoded, Set[Equality]]

case class Equality(tpe: ast.Trees.Type, e1: Encoded, e2: Encoded) extends Product with Serializable

class EqualityTemplate extends Template

class FunctionTemplate extends Template

class LambdaTemplate extends Template

trait Manager extends IncrementalStateWrapper

implicit class MapSeqWrapper[A, B] extends AnyRef

implicit class MapSetWrapper[A, B] extends AnyRef

case class Matcher(key: Either[(Encoded, ast.Trees.Type), ast.Trees.TypedFunDef], args: Seq[Arg], encoded: Encoded) extends Product with Serializable

type Matchers = Map[Encoded, Set[Matcher]]

case class Negative(insts: (ast.Trees.Variable, Encoded)) extends Templates.Polarity with Product with Serializable

type Pointers = Map[Encoded, Encoded]

sealed abstract class Polarity extends AnyRef

case class Positive(subst: Map[ast.Trees.Variable, Arg]) extends Templates.Polarity with Product with Serializable

class QuantificationTemplate extends AnyRef

trait Template extends AnyRef

case class TemplateAppInfo(template: Either[Templates.LambdaTemplate, Encoded], equals: Encoded, args: Seq[Arg]) extends Product with Serializable

type TemplateClauses = (Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Encoded], Map[ast.Trees.Variable, Set[ast.Trees.Variable]], Map[ast.Trees.Variable, Seq[ast.Trees.Expr]], Seq[ast.Trees.Expr], Types, Equalities, Seq[LambdaTemplate], Seq[QuantificationTemplate])

sealed abstract class TemplateInstantiator extends AnyRef

class TemplateStructure extends AnyRef

sealed abstract class TypeUnrolling extends AnyRef

type Types = Map[Encoded, Set[Typing]]

case class Typing(tpe: ast.Trees.Type, arg: Encoded, instantiator: Templates.TemplateInstantiator) extends Product with Serializable

sealed abstract class TypingGenerator extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object CaptureTemplate

object CaptureUnrolling extends Templates.TypeUnrolling with Product with Serializable

object ConstraintTemplate

object ContractGenerator extends Templates.TypingGenerator with Product with Serializable

object ContractUnrolling extends Templates.TypeUnrolling with Product with Serializable

object EqualityTemplate

object FreeGenerator extends Templates.TypingGenerator with Product with Serializable

object FreeUnrolling extends Templates.TypeUnrolling with Product with Serializable

object FunctionMatcher

object FunctionTemplate

object LambdaTemplate

object QuantificationMatcher

object QuantificationTemplate

object Template

object TemplateAppInfo extends Serializable

object TemplateContents extends Serializable

def abort: Boolean

final def asInstanceOf[T0]: T0

def asString(ast: IExpression): String

def blockerChildren(b: Encoded, strict: Boolean = true): Set[Encoded]

def blockerEquals(b: Encoded): Set[Encoded]

def blockerParents(b: Encoded, strict: Boolean = true): Set[Encoded]

def blockerPath(bs: Set[Encoded]): Set[Encoded]

def blockerPath(b: Encoded): Set[Encoded]

def canUnroll: Boolean

def clear(): Unit

def clone(): AnyRef

val context: Context

def correspond(m1: Matcher, m2: Matcher): Option[Boolean]

def correspond(k1: MatcherKey, k2: MatcherKey): Option[Boolean]

def currentGeneration: Int

implicit val debugSection: DebugSectionSolver.type

def decodePartial(e: Encoded, tpe: ast.Trees.Type): Option[ast.Trees.Expr]

lazy val deferFactor: Int