def match_copy_gaps_with_crds(dag: DAG) -> ProofNet:
proof = set()
gaps = list(
filter(
lambda node: is_copy(dag, node) and is_gap(dag, node, _head_deps),
dag.nodes))
gap_types = list(map(lambda node: dag.attribs[node]['type'], gaps))
gap_colors = list(map(lambda type_: type_.argument.color, gap_types))
gap_types = list(map(lambda type_: type_.argument.argument, gap_types))
conjunction_hierarchies = list(
map(
lambda node: participating_conjunctions(
dag, node, exclude_heads=True), gaps))
proof = merge_proofs(
proof,
list(
map(lambda ch, gt, gc: intra_crd_match(dag, ch, gt, gc),
conjunction_hierarchies, gap_types, gap_colors)))
crd_types = list(
map(lambda ch: get_crd_type(dag, fst(fst(ch))),
conjunction_hierarchies))
results = list(map(last_instance_of, crd_types))
matches = list(map(identify_missing, results, gap_types, gap_colors))
return reduce(lambda proof_, pair: match(proof_, fst(pair), snd(pair)),
zip(gap_types, matches), proof)
def match_copies_with_crds(dag: DAG) -> ProofNet:
def get_copy_color(copy_: Node) -> str:
incoming_ = set(map(lambda inc_: inc_.dep, dag.incoming(copy_)))
assert len(incoming_) == 1
return fst(list(incoming_))
proof = set()
copies = list(
filter(
lambda node: is_copy(dag, node) and not is_gap(
dag, node, _head_deps), dag.nodes))
copy_colors = list(map(get_copy_color, copies))
copy_types = list(map(lambda copy: dag.attribs[copy]['type'], copies))
conjunction_hierarchies: List[List[Tuple[Node, List[Optional[Node]]]]] = \
list(map(lambda node: participating_conjunctions(dag, node), copies))
proof = merge_proofs(
proof,
list(
map(lambda ch, ct, cc: intra_crd_match(dag, ch, ct, cc),
conjunction_hierarchies, copy_types, copy_colors)))
crd_types = list(
map(lambda ch: get_crd_type(dag, fst(fst(ch))),
conjunction_hierarchies))
results = list(map(last_instance_of, crd_types))
matches = list(map(identify_missing, results, copy_types, copy_colors))
return reduce(lambda proof_, pair: match(proof_, fst(pair), snd(pair)),
zip(copy_types, matches), proof)
def get_simple_functor(dag: DAG, node: Node) -> WordType:
type_ = dag.attribs[node]['type']
if is_gap(dag, node, _head_deps):
return ColoredType(argument=type_.argument.result,
color=type_.color,
result=type_.result)
else:
return type_
def get_simple_functor(dag: DAG[Node, Any], node: Node) -> WordType:
type_: WordType = dag.attribs[node]['type']
if is_gap(dag, node, HeadDeps):
if isinstance(type_, DiamondType):
return DiamondType(argument=type_.argument.result, diamond=type_.diamond, result=type_.result)
else:
raise ProofError(f'Gap type {type_} is not a DiamondType')
return type_
def get_simple_argument(dag: DAG[Node, Any], node: Node) -> WordType:
type_: WordType = dag.attribs[node]['type']
if is_gap(dag, node, HeadDeps):
if isinstance(type_, DiamondType):
if isinstance(type_.argument, FunctorType):
return type_.argument.argument
else:
raise ProofError(f'Gap argument {type_.argument} is not a FunctorType')
else:
raise ProofError(f'Gap type {type_} is not a DiamondType')
return type_
def add_ghost_nodes(dag: DAG[str, Any]) -> None:
edges = dag.edges
copy_edges = set(filter(lambda edge: is_copy(dag, edge.target), edges))
gap_edges = set(filter(lambda edge: is_gap(dag, edge.target, HeadDeps), edges))
copy_gap_edges = copy_edges.intersection(gap_edges)
copy_edges = copy_edges - copy_gap_edges
copy_gap_edges = set(filter(lambda edge: edge.dep not in HeadDeps, copy_gap_edges))
copies_and_types = list(map(lambda copy: (copy, get_copy_annotation(dag, copy)), copy_edges.union(copy_gap_edges)))
for c, t in copies_and_types:
add_edge(dag, c, t)
def match_copied_gaps_with_crds(dag: DAG[str, str]) -> ProofNet:
def extract_color(type_: WordType) -> str:
if isinstance(type_, FunctorType):
if isinstance(type_.argument, DiamondType):
return type_.argument.diamond
if isinstance(type_.argument, BoxType):
return type_.argument.box
raise ProofError(f'Expected {type_} to be a higher order functor.')
def extract_arg(type_: WordType) -> WordType:
if isinstance(type_, FunctorType):
if isinstance(type_.argument, DiamondType):
return type_.argument.argument
if isinstance(type_.argument, BoxType):
return type_.argument.argument
raise ProofError(f'Expected {type_} to be a higher order functor.')
gaps = list(filter(lambda node:
is_copy(dag, node) and is_gap(dag, node, HeadDeps),
dag.nodes))
gap_types: WordTypes = list(map(lambda node: dag.attribs[node]['type'], gaps))
gap_colors = list(map(lambda gaptype: extract_color(gaptype), gap_types))
gap_args = list(map(lambda gaptype: extract_arg(gaptype), gap_types))
conj_hierarchies = list(map(lambda node:
participating_conjunctions(dag, node, exclude_heads=True),
gaps))
proofs = list(map(lambda ch, ga, gc:
intra_crd_match(dag, ch, ga, gc),
conj_hierarchies,
gap_args,
gap_colors))
crds = list(map(lambda ch:
get_crd_type(dag, fst(fst(ch))),
conj_hierarchies))
results = list(map(lambda crd: last_instance_of(crd), crds))
matches = list(map(lambda res, ga, gc:
identify_missing(res, ga, gc),
results,
gap_args,
gap_colors))
return reduce(lambda proof_, pair:
match(proof_, fst(pair), snd(pair)),
zip(gap_args, matches),
merge_proofs(proofs))
def add_ghost_nodes(dag: DAG) -> DAG:
edges = dag.edges
copies = set(filter(lambda edge: is_copy(dag, edge.target), edges))
gaps = set(filter(lambda edge: is_gap(dag, edge.target, _head_deps),
edges))
copy_gaps = copies.intersection(gaps)
copies = list(copies - copy_gaps)
# todo. assertions
copy_gaps = set(filter(lambda edge: edge.dep not in _head_deps, copy_gaps))
copy_gaps = list(copy_gaps)
copy_types = list(map(lambda copy: get_copy_annotation(dag, copy), copies))
gap_types = list(
map(lambda copy: get_copy_annotation(dag, copy), copy_gaps))
dag = reduce(lambda dag_, pair_: add_edge(dag_, fst(pair_), snd(pair_)),
zip(copies, copy_types), dag)
dag = reduce(lambda dag_, pair_: add_edge(dag_, fst(pair_), snd(pair_)),
zip(copy_gaps, gap_types), dag)
return dag
def get_simple_argument(dag: DAG, node: Node) -> WordType:
type_ = dag.attribs[node]['type']
if is_gap(dag, node, _head_deps):
return type_.argument.argument
else:
return type_
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)
def is_gap_copy_parent(edge_: Edge[str, str]) -> bool:
return edge_.dep in HeadDeps and is_copy(dag, edge_.target) and is_gap(dag, edge_.target, HeadDeps)