Packages

  • package root
    Definition Classes
    root
  • package provingground

    This is work towards automated theorem proving based on learning, using homotopy type theory (HoTT) as foundations and natural language processing.

    This is work towards automated theorem proving based on learning, using homotopy type theory (HoTT) as foundations and natural language processing.

    The implementation of homotopy type theory is split into:

    • the object HoTT with terms, types, functions and dependent functions, pairs etc
    • the package induction with general inductive types and recursion/induction on these.

    The learning package has the code for learning.

    Scala code, including the spire library, is integrated with homotopy type theory in the scalahott package

    We have implemented a functor based approach to translation in the translation package, used for nlp as well as serialization and parsing.

    The library package is contains basic structures implemented in HoTT.

    Definition Classes
    root
  • package translation

    Translation primarily using a functorial framework - see Translator$, for natural language processing as well as serialization, formatted output, parsing, interface with formal languages etc.

    Translation primarily using a functorial framework - see Translator$, for natural language processing as well as serialization, formatted output, parsing, interface with formal languages etc.

    Besides the Translator framework and helper typeclasses is Functors, several structures for concrete languages including our implementation of HoTT are in this package.

    Definition Classes
    provingground
  • object NlpProse

    Stanford dependency trees and associated methods

    Stanford dependency trees and associated methods

    Definition Classes
    translation
  • Advcl
  • Argument
  • Ccomp
  • Conj
  • Cop
  • CopRel
  • DepRel
  • Gt
  • IfMark
  • Lt
  • Modifier
  • Nsubj
  • Parataxis
  • ParseData
  • Prep
  • ProseExtractor
  • ProseTree
  • QuantMod
  • Rcmod
  • SplitTree
  • Token
  • TypeListMatch
  • TypeMatch
  • TypeWordMatch
  • Which

case class ProseTree(root: Token, tree: List[DepRel]) extends ParseData with Product with Serializable

Stanford Dependency tree

Linear Supertypes
Serializable, Product, Equals, ParseData, AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ProseTree
  2. Serializable
  3. Product
  4. Equals
  5. ParseData
  6. AnyRef
  7. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new ProseTree(root: Token, tree: List[DepRel])

Value Members

  1. def -(s: ProseTree): ProseTree

    Remove all edges contained in ProseTree s and with dependent in s

  2. def -(node: Token): ProseTree

    Remove dependency relations with dependent a given token

  3. def --(ss: List[ProseTree]): ProseTree

    Deletes in the sense of method {{-}} a list of trees

  4. def -<(node: Token): ProseTree

    The tree of all descendants of a node

  5. def depView(depRel: DepRel, parents: List[Token]): Elem
  6. def desc(init: List[DepRel]): List[DepRel]

    List of dependency relations descending from an initial list

  7. def descTree(node: Token): ProseTree

    The tree of all descendants of a node

  8. def find(typ: String, word: String): Option[DepRel]

    Find Dependency Relations in heirs specifying both type and dependent word

  9. def find(typ: String): Option[DepRel]

    Find Dependency Relations in heirs of (more generally starting with) a given dependency type

  10. def findAll(typ: String): List[DepRel]

    Find all heirs with dependency the given type

  11. def findAll(typs: List[String]): List[DepRel]

    Find all heirs with dependency one of the given types

  12. def findSplit(typ: String, word: String): Option[(DepRel, ProseTree, ProseTree)]

    Find Dependency Relations in heirs for type and word and split tree accordingly if found

  13. def findSplit(typ: String): Option[(DepRel, ProseTree, ProseTree)]

    Find Dependency Relations in heirs for type and split tree accordingly if found

  14. def heirs: List[DepRel]

    Dependence relations with governor the root

  15. val heirsView: List[Elem]
  16. lazy val labelMap: Map[Token, List[String]]

    Mainly for convenient visualization

  17. def offspring(node: Token): List[DepRel]

    Dependence relations with governor a given token

  18. val pp: PrettyPrinter
  19. def productElementNames: Iterator[String]
    Definition Classes
    Product
  20. val root: Token
  21. def split(r: DepRel): (DepRel, ProseTree, ProseTree)

    Splits into the tree of descendants and the rest

  22. lazy val subTrees: Set[ProseTree]
  23. def toString(): String
    Definition Classes
    ProseTree → AnyRef → Any
  24. val tree: List[DepRel]
  25. def treeAt(head: String): Option[ProseTree]
  26. def treesAt(head: String): Set[ProseTree]
  27. val vertices: Set[Token]
  28. val view: String