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 LambdaExpression
  3. class App extends LambdaExpression
  4. class BinaryPropConnectiveHelper extends AnyRef
  5. type ClosedUnderFOLSub[T] = Substitutable[FOLSubstitution, T, T]
  6. trait ClosedUnderReplacement [T] extends Replaceable[T, T]
  7. type ClosedUnderSub[T] = Substitutable[Substitution, T, T]
  8. class Const extends LambdaExpression with VarOrConst
  9. case class Definition (what: Const, by: LambdaExpression) extends Product with Serializable
  10. implicit final class ExprNameGenerator extends AnyVal
  11. class ExpressionParseHelper extends AnyRef

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

  12. trait FOLAtom extends LambdaExpression with FOLPartialAtom with HOLAtom with FOLFormula
  13. trait FOLAtomConst extends Const with HOLAtomConst with FOLPartialAtom
  14. trait FOLConst extends Const with FOLTerm with FOLFunctionConst
  15. trait FOLExpression extends LambdaExpression
  16. trait FOLFormula extends LambdaExpression with FOLPartialFormula with HOLFormula with FOLExpression
  17. trait FOLFunctionConst extends Const with FOLPartialTerm
  18. trait FOLPartialAtom extends LambdaExpression with HOLPartialAtom
  19. trait FOLPartialTerm extends LambdaExpression
  20. trait FOLQuantifier extends Const with LogicalConstant
  21. class FOLSubstitution extends Substitution
  22. trait FOLTerm extends LambdaExpression with FOLPartialTerm with FOLExpression
  23. trait FOLVar extends Var with FOLTerm
  24. trait HOLAtom extends LambdaExpression with HOLFormula with HOLPartialAtom
  25. trait HOLAtomConst extends Const with HOLPartialAtom
  26. trait HOLFormula extends LambdaExpression
  27. trait HOLPartialAtom extends LambdaExpression
  28. abstract class LambdaExpression extends AnyRef
  29. class LambdaPosition extends AnyRef

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

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

    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.

  30. 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 LambdaExpression 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.

  31. trait LogicalConstant extends Const
  32. trait MatchingAlgorithm extends AnyRef
  33. class MonoidalBinaryPropConnectiveHelper extends BinaryPropConnectiveHelper
  34. class MonomorphicLogicalC extends LogicalC

    Logical constant with a fixed type.

  35. class Normalizer extends AnyRef
  36. class NullaryPropConnectiveHelper extends AnyRef
  37. 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.

  38. trait PropAtom extends Const with PropFormula with FOLAtom with FOLAtomConst
  39. trait PropConnective extends Const with LogicalConstant with PropPartialFormula
  40. trait PropFormula extends LambdaExpression with PropPartialFormula with FOLFormula
  41. class QuantifierC extends LogicalC

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

  42. class QuantifierHelper extends AnyRef
  43. trait ReductionRule extends AnyRef

    Expression-level reduction rule.

    Expression-level reduction rule.

    Examples are beta-reduction in BetaReduction, and delta-reduction in Context.Definitions.

  44. trait Replaceable [-I, +O] extends AnyRef
  45. 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( ... )
  46. class Substitution extends AnyRef

    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.

  47. case class TBase (name: String) extends Ty with Product with Serializable
  48. case class TVar (name: String) extends Ty with Product with Serializable
  49. sealed abstract class Ty extends AnyRef
  50. class UnaryPropConnectiveHelper extends AnyRef
  51. class Var extends LambdaExpression with VarOrConst
  52. trait VarOrConst extends LambdaExpression
  53. 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 BetaReduction extends ReductionRule
  9. object Bottom extends NullaryPropConnectiveHelper
  10. object BottomC extends MonomorphicLogicalC
  11. object Const
  12. object Eq
  13. object EqC extends LogicalC
  14. object Ex extends QuantifierHelper
  15. object ExistsC extends QuantifierC
  16. object ExpressionParseHelper
  17. object FOLAtom
  18. object FOLAtomConst extends FOLHead
  19. object FOLConst
  20. object FOLFunction
  21. object FOLFunctionConst extends FOLHead
  22. object FOLHeadType
  23. object FOLSubstitution
  24. object FOLVar
  25. object ForallC extends QuantifierC
  26. object FunctionType

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

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

  27. object HOLAtom
  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 Or extends MonoidalBinaryPropConnectiveHelper
  37. object OrC extends MonomorphicLogicalC
  38. object Polarity
  39. object Quant
  40. object ReductionRule
  41. object Replaceable
  42. object Substitutable
  43. object Substitution
  44. 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.

  45. object Ti extends TBase
  46. object To extends TBase
  47. object Top extends NullaryPropConnectiveHelper
  48. object TopC extends MonomorphicLogicalC
  49. object Var
  50. object VarOrConst

    Matches constants and variables, but nothing else.

  51. object arity

    Arity of a type.

  52. object baseTypes

    Base types occurring in a type.

  53. object clauseSubsumption
  54. object constants

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

  55. object containedNames
  56. object expressionSize
  57. object freeVariables

    Returns the set of free variables in the given argument.

  58. 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.

  59. object longNormalForm
  60. object normalize
  61. 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.

  62. object replacementContext

    Creates a lambda expression that designates positions to be replaced.

  63. object subTerms

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

  64. object syntacticMGU
  65. object syntacticMatching extends syntacticMatching
  66. object toImplications
  67. 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.

  68. object typeMatching
  69. object typeVars
  70. object variables

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

Inherited from AnyRef

Inherited from Any

Ungrouped