Ejemplo n.º 1
0
def intra_crd_match(dag: DAG, hierarchy: List[Tuple[Node,
                                                    List[Optional[Node]]]],
                    copy_type_: WordType, copy_dep_: str) -> ProofNet:

    hierarchy = list(
        map(lambda pair: (isolate_xs(get_crd_type(dag, fst(pair))), snd(pair)),
            hierarchy))

    hierarchy = list(map(lambda h: list(zip(*h)), hierarchy))

    hierarchy = list(
        filter(lambda pair: snd(pair) is not None,
               list(chain.from_iterable(hierarchy))))

    hierarchy = list(
        map(
            lambda pair:
            (fst(pair), last_instance_of(get_crd_type(dag, snd(pair)))),
            hierarchy))

    try:
        matches = list(
            map(
                lambda pair:
                (identify_missing(fst(pair), copy_type_, copy_dep_),
                 identify_missing(snd(pair), copy_type_, copy_dep_)),
                hierarchy))
    except AttributeError:
        ToGraphViz()(dag)
        print(hierarchy)
        import pdb
        pdb.set_trace()

    return reduce(lambda proof_, pair: match(proof_, fst(pair), snd(pair)),
                  matches, set())
Ejemplo n.º 2
0
def get_copy_annotation(dag: DAG, edge: Edge) -> WordType:

    source = edge.source

    while True:

        conjunction = find_first_conjunction_above(dag, source)
        if conjunction is None:
            ToGraphViz()(dag)
            import pdb
            pdb.set_trace()
        missing_type = get_simple_argument(dag, edge.target)
        crd_type = get_crd_type(dag, conjunction)

        conjunction_daughters = get_conjunction_daughters(dag, conjunction)
        conjunction_daughters = list(
            map(
                lambda daughter: dag.exists_path(daughter, edge.source) or
                daughter == edge.source, conjunction_daughters))
        if any(conjunction_daughters):
            break
        source = conjunction

    daughter_index = conjunction_daughters.index(True)

    xs, result = isolate_xs(crd_type), last_instance_of(crd_type)

    return identify_missing(xs[daughter_index], missing_type, edge.dep)
Ejemplo n.º 3
0
def annotate_dag(dag: DAG) -> Tuple[ProofNet, DAG]:
    proof = set()
    new_dag, idx = annotate_leaves(dag)
    new_dag = add_ghost_nodes(new_dag)

    try:
        if dag.edges:

            temp = iterate_simple_fringe(new_dag)
            if temp is not None:
                proof, new_dag = temp

            new_dag = delete_ghost_nodes(new_dag)
            copy_proof = match_copies_with_crds(new_dag)
            copy_gap_proof = match_copy_gaps_with_crds(new_dag)
            proof = merge_proofs(proof, [copy_proof, copy_gap_proof])
    except ProofError as e:
        raise e

    root_type = new_dag.attribs[fst(list(new_dag.get_roots()))]['type']

    if not isinstance(root_type, AtomicType):
        raise ProofError('Derived a complex type.')

    idx, conclusion = polarize_and_index(root_type.depolarize(), False, idx)

    proof = match(proof, root_type, conclusion)

    positives = set(map(fst, proof))
    negatives = set(map(snd, proof))
    immaterial = set(
        map(
            lambda type_: type_.index,
            filter(
                lambda type_: type_ == placeholder,
                map(lambda leaf: new_dag.attribs[leaf]['type'],
                    filter(new_dag.is_leaf, dag.nodes)))))

    if set.union(positives, negatives, immaterial) != set(range(idx)):
        ToGraphViz()(new_dag)
        print(
            set(range(idx)).difference(
                set(map(fst, proof)).union(set(map(snd, proof)))))
        raise ProofError('Unmatched types.')

    return proof, new_dag
Ejemplo n.º 4
0
def refine_body(dag: DAG) -> DAG:
    bodies = list(dag.get_edges('body'))
    to_add, to_remove = set(), set()
    for body in bodies:
        common_source = dag.outgoing(body.source)
        match = list(
            filter(lambda edge: edge.dep in ('cmp', 'rhd', 'whd'),
                   common_source))
        if len(match) != 1:
            from LassyExtraction.viz import ToGraphViz
            import pdb
            ToGraphViz()(dag)
            pdb.set_trace()
        match = fst(match)
        new_dep = match.dep + '_body'
        to_add.add(Edge(source=body.source, target=body.target, dep=new_dep))
        to_remove.add(body)
    return DAG(nodes=dag.nodes,
               edges=dag.edges.difference(to_remove).union(to_add),
               attribs=dag.attribs,
               meta=dag.meta)
Ejemplo n.º 5
0
from LassyExtraction.extraction import Extraction, _cat_dict, _pt_dict, _head_deps, _mod_deps, ExtractionError
from LassyExtraction.lassy import Lassy
from LassyExtraction.proofs import Prove, ProofError
from LassyExtraction.transformations import Transformation
from LassyExtraction.viz import ToGraphViz

from typing import Optional, Union, Tuple, List
from LassyExtraction.graphutils import DAG
from LassyExtraction.proofs import ProofNet

_lassy = Lassy()
_transform = Transformation()
_extract = Extraction(_cat_dict, _pt_dict, 'pt', _head_deps, _mod_deps)
_prove = Prove()
_viz = ToGraphViz()


def test(size, start=0):
    meta = [{'src': _lassy[i][1]} for i in range(start, start + size)]

    transformed = list(
        chain.from_iterable(
            list(
                map(
                    _transform,
                    list(
                        map(lambda i: _lassy[i][2],
                            range(start, start + size))), meta))))
    transformed = list(filter(lambda t: t is not None, transformed))
Ejemplo n.º 6
0
def annotate_simple_branch(dag: DAG,
                           parent: Node) -> Tuple[ProofNet, WordType]:
    def simplify_crd(crd_type: WordType,
                     arg_types_: List[WordType]) -> WordType:
        xs, result = isolate_xs(crd_type), last_instance_of(crd_type)

        if len(set(map(depolarize, arg_types))) > 1:
            raise ProofError('Non polymorphic conjunction.')

        if arg_types_ == xs:
            return crd_type
        else:
            xs, result = list(map(lambda x: x.result, xs)), result.result
            crd_type = reduce(
                lambda res_, arg_: ColoredType(arg_, res_, 'cnj'),
                reversed(xs), result)
            return simplify_crd(crd_type, arg_types_)
            # xs, result = list(map(get_functor_result, xs)), get_functor_result(result)
        # return reduce(lambda res_, arg_: ColoredType(arg_, res_, 'cnj'), reversed(xs), result)

    def is_gap_copy_parent(edge_: Edge) -> bool:
        return edge_.dep in _head_deps and is_copy(
            dag, edge_.target) and is_gap(dag, edge_.target, _head_deps)

    branch_proof = set()

    outgoing = dag.outgoing(parent)
    outgoing = set(
        filter(
            lambda edge: not is_copy(dag, edge.target) or is_gap_copy_parent(
                edge), outgoing))

    head = list(
        filter(
            lambda out: out.dep in _head_deps and dag.attribs[out.target][
                'type'] != placeholder, outgoing))
    if len(head) != 1:
        ToGraphViz()(dag)
        import pdb
        pdb.set_trace()
    head = fst(head)
    outgoing = list(filter(lambda out: out.dep not in _head_deps, outgoing))
    mods = list(filter(lambda out: out.dep in _mod_deps, outgoing))
    mods = order_nodes(dag, set(map(lambda out: out.target, mods)))
    args = list(filter(lambda out: out.dep not in _mod_deps, outgoing))
    sorted_args = order_nodes(dag, set(map(lambda out: out.target, args)))
    args = sorted(args, key=lambda x: sorted_args.index(x.target))
    arg_types = list(
        map(lambda out: get_simple_argument(dag, out.target), args))
    arg_deps = list(map(lambda out: out.dep, args))

    if dag.attribs[parent]['cat'] == 'conj':
        branch_output = simplify_crd(dag.attribs[head.target]['type'],
                                     arg_types)
    else:
        branch_output = get_simple_functor(dag, head.target)

    arg_proof, branch_output = align_args(branch_output, arg_types, arg_deps)
    mod_proof, branch_output = align_mods(
        branch_output,
        list(map(lambda node: get_simple_argument(dag, node), mods)))
    branch_proof = merge_proofs(branch_proof, (arg_proof, mod_proof))
    return branch_proof, branch_output
Ejemplo n.º 7
0
    def impose_order(
            conjunctions_: Nodes) -> List[Tuple[Node, List[Optional[Node]]]]:
        daughters = list(conjunctions_)
        daughters = list(
            zip(
                daughters,
                list(
                    map(lambda conj: get_conjunction_daughters(dag, conj),
                        daughters))))

        daughters_connections = list(
            map(
                lambda pair:
                # the conjunction
                (
                    # the conjunction
                    fst(pair),
                    # the subset of conjunctions contained by each daughter
                    list(
                        map(
                            lambda daughter: set(
                                filter(
                                    lambda other: dag.exists_path(
                                        daughter, other) or daughter == other,
                                    conjunctions_)), snd(pair)))),
                daughters))

        daughters_connections = list(
            map(
                lambda pair: (
                    fst(pair),
                    # the subset of connections that have the most paths to node
                    list(
                        map(
                            lambda daughter_connections: set(
                                filter(
                                    lambda connection: not any(
                                        map(
                                            lambda other: len(
                                                dag.distinct_paths_to(
                                                    other, node)) > len(
                                                        dag.distinct_paths_to(
                                                            connection, node)),
                                            daughter_connections)),
                                    daughter_connections)), snd(pair)))),
                daughters_connections))

        daughters_connections = list(
            map(
                lambda pair: (
                    fst(pair),
                    # the singular connection that lies lowest (not over any conjunction?)
                    list(
                        map(
                            lambda daughter_connections: set(
                                filter(
                                    lambda connection: not any(
                                        map(
                                            lambda other: other in dag.
                                            points_to(connection
                                                      ), daughter_connections)
                                    ), daughter_connections)), snd(pair)))),
                daughters_connections))

        if any(
                map(
                    lambda conj: any(
                        map(
                            lambda conns: len(list(filter(lambda x: x, conns)))
                            > 1, snd(conj))), daughters_connections)):
            ToGraphViz()(dag)
            raise ProofError('wtf')

        daughters_connections = list(
            map(
                lambda pair: (fst(pair),
                              list(
                                  map(
                                      lambda daughter: fst(list(daughter))
                                      if len(daughter) else None, snd(pair)))),
                daughters_connections))

        return daughters_connections
Ejemplo n.º 8
0
def participating_conjunctions(dag: DAG, node: Node, exclude_heads: bool = False) \
        -> List[Tuple[Node, List[Optional[Node]]]]:
    def impose_order(
            conjunctions_: Nodes) -> List[Tuple[Node, List[Optional[Node]]]]:
        daughters = list(conjunctions_)
        daughters = list(
            zip(
                daughters,
                list(
                    map(lambda conj: get_conjunction_daughters(dag, conj),
                        daughters))))

        daughters_connections = list(
            map(
                lambda pair:
                # the conjunction
                (
                    # the conjunction
                    fst(pair),
                    # the subset of conjunctions contained by each daughter
                    list(
                        map(
                            lambda daughter: set(
                                filter(
                                    lambda other: dag.exists_path(
                                        daughter, other) or daughter == other,
                                    conjunctions_)), snd(pair)))),
                daughters))

        daughters_connections = list(
            map(
                lambda pair: (
                    fst(pair),
                    # the subset of connections that have the most paths to node
                    list(
                        map(
                            lambda daughter_connections: set(
                                filter(
                                    lambda connection: not any(
                                        map(
                                            lambda other: len(
                                                dag.distinct_paths_to(
                                                    other, node)) > len(
                                                        dag.distinct_paths_to(
                                                            connection, node)),
                                            daughter_connections)),
                                    daughter_connections)), snd(pair)))),
                daughters_connections))

        daughters_connections = list(
            map(
                lambda pair: (
                    fst(pair),
                    # the singular connection that lies lowest (not over any conjunction?)
                    list(
                        map(
                            lambda daughter_connections: set(
                                filter(
                                    lambda connection: not any(
                                        map(
                                            lambda other: other in dag.
                                            points_to(connection
                                                      ), daughter_connections)
                                    ), daughter_connections)), snd(pair)))),
                daughters_connections))

        if any(
                map(
                    lambda conj: any(
                        map(
                            lambda conns: len(list(filter(lambda x: x, conns)))
                            > 1, snd(conj))), daughters_connections)):
            ToGraphViz()(dag)
            raise ProofError('wtf')

        daughters_connections = list(
            map(
                lambda pair: (fst(pair),
                              list(
                                  map(
                                      lambda daughter: fst(list(daughter))
                                      if len(daughter) else None, snd(pair)))),
                daughters_connections))

        return daughters_connections

    incoming = list(
        filter(lambda edge: edge.dep not in _head_deps or not exclude_heads,
               dag.incoming(node)))
    parents = set(map(lambda edge: edge.source, incoming))
    top = dag.first_common_predecessor(parents)
    if top is None or dag.attribs[top]['cat'] != 'conj':
        ToGraphViz()(dag)
        raise ProofError('Top is not a conj or no top.')
    conjunctions = _cats_of_type(
        dag, 'conj',
        dag.points_to(top).intersection(dag.pointed_by(node)).union({top}))
    conjunctions = set(
        filter(lambda conj: len(dag.distinct_paths_to(conj, node)) > 1,
               conjunctions))
    conjunctions = sorted(impose_order(conjunctions),
                          key=lambda pair: fst(pair) == top,
                          reverse=True)
    return conjunctions