Metadata-Version: 1.2
Name: ALPAFA
Version: 0.2
Summary: Algorithm for lexicocentric parameter acquisition by feature assignment
Home-page: https://www.github.com/timothybazalgette/alpafa
Author: Timothy Bazalgette
Author-email: timothy.bazalgette@gmail.com
License: MIT
Description: ALPAFA
        ======
        
        ALPAFA (/ˌælˈpæfə/, Algorithm for Lexicocentric Parameter Acquisition by Feature Assignment) is a
        Python implementation of the algorithm described in chapter 2 of my 2015 PhD thesis, `Algorithmic
        Acquisition of Focus Parameters <http://ling.auf.net/lingbuzz/003006>`_ (AAFP), which grew out of
        an attempt to formalise certain proposals of the `Rethinking Comparative Syntax
        <http://recos-dtal.mml.cam.ac.uk/>`_ (ReCoS) project. The algorithm takes a set of heads, each of
        which is specified for a number of discoverable properties, and uses a "prominence" order of
        properties to construct a minimal categorial system. This is achieved by attempting to assign each
        new feature to all heads of the "largest" existing category, and, if this fails, making the
        "smallest" categorial division possible. This algorithm is a putative component of domain-general
        categorisation processes that is designed to capture the structured typological and historical
        syntactic variation seen crosslinguistically through third factor principles. The motivation for
        and behaviour of this algorithm is described in detail in chapters 1 and 2 of AAFP, including
        extensions for unvalued features, movement triggers, and c-selection. Chapter 10 presents and
        compares worked examples of inputs to the algorithm for toy fragment grammars of 6 varieties.
        
        Links
        =====
        
        * AAFP: http://ling.auf.net/lingbuzz/003006
        * ReCoS project: http://recos-dtal.mml.cam.ac.uk/
        * Github: https://www.github.com/timothybazalgette/alpafa
        * PyPI: https://pypi.python.org/pypi/alpafa
        
        Installation
        ============
        
        Install with pip:
        
        ``$ pip install alpafa`` or ``$ pip3 install alpafa``
        
        Input file format
        =================
        
        Input files are closely based on the set notation used for input specifications in AAFP, but are
        somewhat simplified for ease of creation and reading. They should be plain text files with UTF-8
        compatible encodings. Place each head name on a separate line, followed by a colon and a
        comma-separated list of properties. The prominence order should be placed on another line, starting
        ``prominence=``, followed by a comma-separated list of property names. Properties that are sets or
        ordered pairs remain the same as in AAFP, though all sets must be given in full (i.e. no set-builder
        notation). All spaces and blank lines will be ignored. An example specification for a toy fragment
        of English is as follows::
        
            Cmat: comp, {T}}
            Cwh: comp, int, <whq, m>, {T}
            Crel: n, comp, nom, {T}
            Csub: comp, arg, {T}
            T: <phi, m>, {V, Copadj}
            V: v, cat, {Csub, D, Dwh}
            Copadj: v, {A}
            D: n, arg, {Crel, φ}
            Dwh: n, arg, wh, whq, {Crel, φ}
            only: invis, excl, {D}
            OpCR: invis, {φ, N}
            φ: n, nom, phi, low, {noun}, {N}
            ind: n
            N: n, cat, noun, low
            A: cat
            Focfeat: invis, foc, feat, {Cmat, Cwh, Crel, Csub, T, V, Copadj, D, Dwh, only, OpCR, φ, ind, N, A, Focfeat}
        
            prominence = n, v, cat, noun, comp, arg, wh, whq, nom, phi, int, invis, excl, feat, foc, low
        
        Included with the source code are example input files for the 6 toy fragment grammars in AAFP
        chapter 10.
        
        Ouput
        =====
        
        ALPAFA defaults to outputting a list of the heads with their categorial and dependent features,
        along with a brief description of the algorithm's operation. Feature bundles are separated by tabs
        for easy formatting when pasted into word processors - I may incorporate prettier printing in later
        versions. There are a number of options for more detailed output of the algorithm's operation and
        the categories created by it, discussed in the following section. ::
        
            Cmat	[-N,-V,-CAT,+COMP,-ARG,-INT]	(-N,-V,-CAT,-COMP,-INVIS)
            Cwh	[-N,-V,-CAT,+COMP,-ARG,+INT]	(-N,-V,-CAT,-COMP,-INVIS)	[uwhq^]
            Crel	[+N,-CAT,+COMP,-ARG,+NOM,-LOW]	(-N,-V,-CAT,-COMP,-INVIS)
            Csub	[-N,-V,-CAT,+COMP,+ARG]	(-N,-V,-CAT,-COMP,-INVIS)
            T	[-N,-V,-CAT,-COMP,-ARG,-INVIS]	(-N,+V)	[uphi^]
            V	[-N,+V,+CAT]	(-CAT,+ARG)
            Copadj	[-N,+V,-CAT,-COMP,-ARG]	(-N,-V,+CAT)
            D	[+N,-CAT,-COMP,+ARG,-WH,-LOW]	(+N,-CAT,-ARG,+NOM)
            Dwh	[+N,-CAT,-COMP,+ARG,+WH,-LOW]	(+N,-CAT,-ARG,+NOM)	[vwhq]
            only	[-N,-V,-CAT,-COMP,-ARG,+INVIS,+EXCL]	(+N,-CAT,-COMP,+ARG,-WH)
            OpCR	[-N,-V,-CAT,-COMP,-ARG,+INVIS,-EXCL,-FEAT]	(+N,+LOW)
            φ	[+N,-CAT,-COMP,-ARG,+NOM,+LOW]	(+N,+CAT)	[vphi,unoun]
            ind	[+N,-CAT,-COMP,-ARG,-NOM,-LOW]
            N	[+N,+CAT,+LOW]		[vnoun]
            A	[-N,-V,+CAT]
            Focfeat	[-N,-V,-CAT,-COMP,-ARG,+INVIS,-EXCL,+FEAT]	()	[vfoc]
        
            Over 82 loops, 28 of which were non-vacuous, ALPAFA created 67 categories using 12 pairs of categorial features, and assigned 16 non-categorial features.
        
        Usage
        =====
        
        ALPAFA is implemented as a command line utility. Use the following syntax to read from an input file
        and write the output of ALPAFA to a file (note that this will overwrite existing files of the same
        name as the output):
        
        ``$ alpafa input_file output_file``
        
        More complex options can be seen with ``$ alpafa -h`` or ``$ alpafa --help``::
        
            usage: alpafa [-h] [--no_uf] [--no_cselect] [--log] [--categories]
                          [--dependents]
                          input_file output_file
        
            Applies the algorithm from AAFP to a correctly formatted input file.
        
            positional arguments:
              input_file    correctly formatted UTF-8 input file
              output_file   name of file to output
        
            optional arguments:
              -h, --help    show this help message and exit
              --no_uf       do not implement unvalued features
              --no_cselect  do not implement c-selection
              --log         include a log of algorithm operations
              --categories  list all categories before heads
              --dependents  list all dependent features below their relevant categories
                            (implies --categories)
        
Keywords: parameters lexicocentrism recos features linguistics
Platform: any
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Requires-Python: >=3
