Packages

package expr

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. expr
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. case class -> (in: Ty, out: Ty) extends Ty with Product with Serializable
  2. class Abs extends Expr
  3. class App extends Expr
  4. trait Atom extends Expr with Formula with HOLPartialAtom
  5. class BinaryPropConnectiveHelper extends AnyRef
  6. type ClosedUnderFOLSub[T] = Substitutable[FOLSubstitution, T, T]
  7. trait ClosedUnderReplacement [T] extends Replaceable[T, T]
  8. type ClosedUnderSub[T] = Substitutable[Substitution, T, T]
  9. class Const extends Expr with VarOrConst
  10. case class Definition (what: Const, by: Expr) extends Product with Serializable
  11. abstract class Expr extends AnyRef
  12. implicit final class ExprNameGenerator extends AnyVal
  13. trait ExprSubstitutable1 extends AnyRef
  14. trait ExprSubstitutable2 extends ExprSubstitutable1
  15. trait ExprSubstitutable3 extends ExprSubstitutable2
  16. trait ExprSubstitutable4 extends ExprSubstitutable3
  17. trait ExprSubstitutable5 extends ExprSubstitutable4
  18. trait ExprSubstitutable6 extends ExprSubstitutable5
  19. class ExpressionParseHelper extends AnyRef

    Extension class that provides string interpolation functions for various expression types.

  20. trait FOLAtom extends Expr with FOLPartialAtom with Atom with FOLFormula
  21. trait FOLAtomConst extends Const with HOLAtomConst with FOLPartialAtom
  22. trait FOLConst extends Const with FOLTerm with FOLFunctionConst
  23. trait FOLExpression extends Expr
  24. trait FOLFormula extends Expr with FOLPartialFormula with Formula with FOLExpression
  25. trait FOLFunctionConst extends Const with FOLPartialTerm
  26. trait FOLPartialAtom extends Expr with HOLPartialAtom
  27. trait FOLPartialTerm extends Expr
  28. trait FOLQuantifier extends Const with LogicalConstant
  29. class FOLSubstitution extends Substitution
  30. trait FOLTerm extends Expr with FOLPartialTerm with FOLExpression
  31. trait FOLVar extends Var with FOLTerm
  32. trait Formula extends Expr
  33. trait HOLAtomConst extends Const with HOLPartialAtom
  34. trait HOLPartialAtom extends Expr
  35. class LambdaPosition extends AnyRef

    Represents a position in a at.logic.gapt.expr.Expr.

    Represents a position in a at.logic.gapt.expr.Expr.

    Positions are represented by lists of Integers. The empty list denotes the expression itself. A nonempty list denotes a position in the left or right subexpression according to whether it starts with 1 or 2.

  36. abstract class LogicalC extends AnyRef

    Helper class for logical constants.

    Helper class for logical constants.

    The logical constans are the propositional connectives, the quantifiers, bottom, top, and the equality constant. A logical constant is different from an expression consisting of only this logical constant, as the expression is an object of type Expr and needs to have a definite type.

    A logical constant consists of a name (e.g. "∀"), and a set of possible types, (e.g. (Ti->To)->To, ((Ti->Ti)->To)->To, ...). Subclasses need to implement the function matchType, which matches these possible types. This way we can handle the parametric types of the quantifiers.

  37. trait LogicalConstant extends Const
  38. trait MatchingAlgorithm extends AnyRef
  39. class MonoidalBinaryPropConnectiveHelper extends BinaryPropConnectiveHelper
  40. class MonomorphicLogicalC extends LogicalC

    Logical constant with a fixed type.

  41. case class Normalizer (rules: Set[ReductionRule]) extends Product with Serializable
  42. class NullaryPropConnectiveHelper extends AnyRef
  43. sealed abstract class Polarity extends AnyRef

    Polarity of a formula.

    Polarity of a formula.

    There are two polarities, positive/in-succedent and negative/in-antecedent. Polarities serve multiple purposes:

    • They distinguish strong and weak quantifiers. A universal (∀) quantifier in positive/in-succedent polarity is strong (requires an eigenvariable/Skolem inference), and is weak in negative/in-antecedent polarity (can be instantiated with any term).
    • They guide the construction of expansion trees and their deep formulas. A merge in positive polarity has a disjunction as deep formula, in negative polarity it has a conjunction.
    • They specify the side/cedent of a sequent.

    Our convention is based on proofs in LK:

    • formulas in the succedent are positive
    • formulas in the antecedent are negative

    This is used consistently, except for a major exception: in resolution proofs, the polarity is reversed. A formula in the antecedent of a clause in a resolution proof has the negative/in-antecedent polarity (as it is in the antecedent of a sequent). However upon conversion to LK/ET, the polarity switches to positive/in-succedent polarity.

  44. class PreSubstitution extends AnyRef

    An unvalidated substitution, you should use Substitution instead.

  45. trait PropAtom extends Const with PropFormula with FOLAtom with FOLAtomConst
  46. trait PropConnective extends Const with LogicalConstant with PropPartialFormula
  47. trait PropFormula extends Expr with PropPartialFormula with FOLFormula
  48. class QuantifierC extends LogicalC

    A logical constant describing a quantifier, which is of type (α->To)->To.

  49. class QuantifierHelper extends AnyRef
  50. case class ReductionRule (lhs: Expr, rhs: Expr) extends Product with Serializable
  51. trait Replaceable [-I, +O] extends AnyRef
  52. trait Substitutable [-S <: Substitution, -T, +U] extends AnyRef

    Trait that describes the following relation between types S, T, U: If a substitution of type S is applied to an element of type T, the result will have type U.

    Trait that describes the following relation between types S, T, U: If a substitution of type S is applied to an element of type T, the result will have type U.

    S

    A subtype of Substitution.

    T

    The input type.

    U

    The output type.

    Annotations
    @implicitNotFound( ... )
  53. class Substitution extends PreSubstitution

    A substitution is a mapping from variables to lambda-expressions which differs from the identity on finitely many variables.

    A substitution is a mapping from variables to lambda-expressions which differs from the identity on finitely many variables. Therefore: 1) each variable is mapped to only one lambda expression 2) the order of the variable-mappings is irrelevant 3) all variable-mappings are applied simultaneously to a term i.e. {x |-> y, y |-> a}x = y and not a.

    As the lambda calculus contains variable binders, substitution can only be defined up to alpha-equivalence. When applying a substitution, bound variables are renamed if needed.

  54. case class TBase (name: String, params: List[Ty]) extends Ty with Product with Serializable
  55. case class TVar (name: String) extends Ty with Product with Serializable
  56. sealed abstract class Ty extends AnyRef
  57. class UnaryPropConnectiveHelper extends AnyRef
  58. class Var extends Expr with VarOrConst
  59. trait VarOrConst extends Expr
  60. class syntacticMatching extends MatchingAlgorithm

Value Members

  1. implicit def stringInterpolationForExpressions(sc: StringContext)(implicit file: File, line: Line, sig: BabelSignature): ExpressionParseHelper
  2. object Abs
  3. object All extends QuantifierHelper
  4. object And extends MonoidalBinaryPropConnectiveHelper
  5. object AndC extends MonomorphicLogicalC
  6. object App
  7. object Apps
  8. object Atom
  9. object BetaReduction extends Normalizer
  10. object Bottom extends NullaryPropConnectiveHelper
  11. object BottomC extends MonomorphicLogicalC
  12. object Const
  13. object Eq
  14. object EqC extends LogicalC
  15. object Ex extends QuantifierHelper
  16. object ExistsC extends QuantifierC
  17. object ExpressionParseHelper
  18. object FOLAtom
  19. object FOLAtomConst extends FOLHead
  20. object FOLConst
  21. object FOLFunction
  22. object FOLFunctionConst extends FOLHead
  23. object FOLHeadType
  24. object FOLSubstitution
  25. object FOLVar
  26. object ForallC extends QuantifierC
  27. object FunctionType

    Function type from_0 -> (from_1 -> ...

    Function type from_0 -> (from_1 -> ... (from_n -> to)).

  28. object HOLAtomConst
  29. object HOLFunction
  30. object Imp extends BinaryPropConnectiveHelper
  31. object ImpC extends MonomorphicLogicalC
  32. object LambdaPosition
  33. object Neg extends UnaryPropConnectiveHelper
  34. object NegC extends MonomorphicLogicalC
  35. object NonLogicalConstant
  36. object Normalizer extends Serializable
  37. object Or extends MonoidalBinaryPropConnectiveHelper
  38. object OrC extends MonomorphicLogicalC
  39. object Polarity
  40. object PreSubstitution
  41. object Quant
  42. object ReductionRule extends Serializable
  43. object Replaceable
  44. object Substitutable extends ExprSubstitutable6
  45. object Substitution
  46. object TBase extends Serializable
  47. object TermReplacement

    A term replacement homomorphically extends a partial function on lambda expressions to all lambda expressions.

    A term replacement homomorphically extends a partial function on lambda expressions to all lambda expressions.

    This is done on a "best effort" basis. Replacing constants by ground terms of the same type will usually work, anything beyond that might or might not work.

  48. object Ti extends TBase
  49. object To extends TBase
  50. object Top extends NullaryPropConnectiveHelper
  51. object TopC extends MonomorphicLogicalC
  52. object Var
  53. object VarOrConst

    Matches constants and variables, but nothing else.

  54. object arity

    Arity of a type.

  55. object baseTypes

    Base types occurring in a type.

  56. object clauseSubsumption
  57. object constants

    Returns the set of non-logical constants occuring in the given argument.

  58. object containedNames
  59. object expressionSize
  60. object freeVariables

    Returns the set of free variables in the given argument.

  61. object isConstructorForm
  62. object isGround
  63. object isInVNF

    A lambda term is in variable-normal form (VNF) if different binders bind different variables, and bound variables are disjoint from the free ones.

  64. object longNormalForm
  65. object normalize
  66. object preExpr

    Intermediate representation for expressions without explicit types.

    Intermediate representation for expressions without explicit types.

    The main application is during parsing: the at.logic.gapt.formats.babel.BabelParser produces pre-expressions.

    This representation is intended to be as simple as possible, all higher-level constructs (such as <-> or ∀) are already desugared into simply-typed lambda terms.

    It differs from the "real" lambda calculus in at.logic.gapt.expr in three major ways:

    1. There are type meta-variables.
    2. There are type annotations.
    3. Free variables, bound variables, and constants are not distinguished; they are all stored as "identifiers".
  67. object rename

    get a new variable/constant (similar to the current and) different from all variables/constants in the blackList, returns this variable if this variable is not in the blackList.

  68. object replacementContext

    Creates a lambda expression that designates positions to be replaced.

  69. object subTerms

    Returns the set of all subterms of the given lambda term.

  70. object syntacticMGU
  71. object syntacticMatching extends syntacticMatching
  72. object toImplications
  73. object toVNF

    Transforms an expression into an alpha-equivalent expression in variable-normal form, where no two binders bind the same variable, and the bound variables are disjoint from the free ones.

  74. object typeVariables
  75. object variables

    Returns the set of all variables occurring in the given argument (including vacuously bound variables).

Inherited from AnyRef

Inherited from Any

Ungrouped