Packages

package expr

Source
package.scala
Linear Supertypes
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. class Abs extends Expr
  2. class App extends Expr
  3. trait Atom extends Expr with Formula with HOLPartialAtom
  4. class BinaryPropConnectiveHelper extends AnyRef
  5. type ClosedUnderFOLSub[T] = Substitutable[FOLSubstitution, T, T]
  6. type ClosedUnderReplacement[T] = Replaceable[T, T]
  7. type ClosedUnderSub[T] = Substitutable[Substitution, T, T]
  8. class Const extends Expr with VarOrConst
  9. case class Definition(what: Const, by: Expr) extends Update with Product with Serializable
  10. abstract class Expr extends AnyRef
  11. implicit final class ExprNameGenerator extends AnyVal
  12. trait ExprSubstitutable1 extends AnyRef
  13. trait ExprSubstitutable2 extends ExprSubstitutable1
  14. trait ExprSubstitutable3 extends ExprSubstitutable2
  15. trait ExprSubstitutable4 extends ExprSubstitutable3
  16. trait ExprSubstitutable5 extends ExprSubstitutable4
  17. trait ExprSubstitutable6 extends ExprSubstitutable5
  18. trait ExprSubstitutable7 extends ExprSubstitutable6
  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. case class LambdaPosition(list: List[Int]) extends Product with Serializable

    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.

    list

    The list of integers describing the position.

  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. final case class Polarity(inSuc: Boolean) extends AnyVal with Product with Serializable

    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 ReplaceableInstances0 extends AnyRef
  53. trait ReplaceableInstances1 extends ReplaceableInstances0
  54. trait ReplaceableInstances2 extends ReplaceableInstances1
  55. trait SeqSubstitutable extends AnyRef
  56. 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( ... )
  57. 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.

  58. case class TArr(in: Ty, out: Ty) extends Ty with Product with Serializable
  59. case class TBase(name: String, params: List[Ty]) extends Ty with Product with Serializable
  60. case class TVar(name: String) extends Ty with Product with Serializable
  61. sealed abstract class Ty extends AnyRef
  62. class UnaryPropConnectiveHelper extends AnyRef
  63. class Var extends Expr with VarOrConst
  64. trait VarOrConst extends Expr
  65. class syntacticMatching extends MatchingAlgorithm

Value Members

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

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

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

  30. object HOLAtomConst
  31. object HOLFunction
  32. object Iff
  33. object Imp extends BinaryPropConnectiveHelper
  34. object ImpC extends MonomorphicLogicalC
  35. object LambdaPosition extends Serializable
  36. object Neg extends UnaryPropConnectiveHelper
  37. object NegC extends MonomorphicLogicalC
  38. object NonLogicalConstant
  39. object Normalizer extends Serializable
  40. object Or extends MonoidalBinaryPropConnectiveHelper
  41. object OrC extends MonomorphicLogicalC
  42. object Polarity extends Serializable
  43. object PreSubstitution
  44. object PropAtom
  45. object Quant
  46. object ReductionRule extends Serializable
  47. object Replaceable extends ReplaceableInstances2
  48. object Substitutable extends ExprSubstitutable7 with SeqSubstitutable
  49. object Substitution
  50. object TBase extends Serializable
  51. 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.

  52. object Ti extends TBase
  53. object To extends TBase
  54. object Top extends NullaryPropConnectiveHelper
  55. object TopC extends MonomorphicLogicalC
  56. object Var
  57. object VarOrConst

    Matches constants and variables, but nothing else.

  58. object arity

    Arity of a type.

  59. object baseTypes

    Base types occurring in a type.

  60. object clauseSubsumption
  61. object constants

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

  62. object containedNames
  63. object expressionSize
  64. object freeVariables

    Returns the set of free variables in the given argument.

  65. object isConstructorForm
  66. object isGround
  67. 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.

  68. object longNormalForm
  69. object normalize
  70. 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".
  71. 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.

  72. object replacementContext

    Creates a lambda expression that designates positions to be replaced.

  73. object subTerms

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

  74. object syntacticMGU
  75. object syntacticMatching extends syntacticMatching
  76. object toImplications
  77. 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.

  78. object typeVariables
  79. object variables

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

Inherited from AnyRef

Inherited from Any

Ungrouped