samyadaleh/cl-toolbox

A Parsing-as-Deduction system that parses with different parsing algorithms and some related tools for educational purposes.

cl-toolbox's Issues

Add the formal definitions of the dynamic rules to their string representations

Also make sure that they don't set their name outside the constructor anymore.

Make sure that each DeductionRule can be used with one item as often as new items are generated

Either run until it returns 0 consequences or try it out with all combinations of existing items.

Make that Deduction beside true or false also/optionally can return the chart

Add CYK parsing for C2F

It should be a simple extention of CYK for CNF.
Maybe just convert a grammar to C2F in this stage if general CYK parsing is not available yet.

TAG get derivation tree

Make toolbox runable per command line, create runable jar

Add CFG CYK Parsing

At first for CNF. :)
If the grammar is not in CNF, convert it to CNF and drop the user a note.

Constructor PCFG from CFG

Don't add backpointers if they already exist in another order

sRCG remove epsilon-productions

Also add check containsEpsilonProductions().

Convert MCFG to SRCG and vice versa

Add Astar Parsing for CFG

TAG get derived tree

Display Trees

• from bracket format or from Tree-class (I can convert them into each other) or from deduction items - from Tree class is best
• with dot: top, bottom, la, ra, lb, rb
• with crossing edges (maybe needs other format for that or pointers to words in sentence, see how TiGer does that)
• with indices at the or between the terminals to display items

Convert TAG to sRCG

Marry JUnit

I don't want to live without it anymore. I miss it so much. <3

Add .sh and .bat scripts that call the jar with encoding

So people don't have to type it in all the time.

When running from the command line, display final chart in graphical window

This should display special characters correctly.

CFG replace t in rhs > 1 by A -> t

Convert CFG to sRCG

CFG remove useless NTs

Implement placeholder parameter for items that always match

Add Javadoc comments for all public classes and methods

CFG remove epsilon productions

CFG get derived tree

Add check if grammar is not appropriate for parsing and print warning

For instance if you parse a TAG that is not binarized with CYK it will just fail, even if the word is in the grammar.

CFG remove left recursion

Update Tree class to represent crossing edges

Add terminals/leaves separately, in bracket format allow pointers to the leaves.
Tree parser should be able to handle both formats.
Tag/ grammar parser needs check. No crossing edges allowed for Tag. (Or let's try once and see what happens. :))

Create Earley for LCFRS

TAG allow epsilon in trees as leaf

How do you want to create a leaf with empty string if the tokenizer ignores spaces? lol

Allow to show a trace of only successful items

CFG binarize

Order cRCG

Also add check isOrdered().

Create CYK for LCFRS

Create optional parameter -success that prints only successful items from a parsing trace

Constructor CFG from PCFG

TAG implement Null Adjoin and Obligatory Adjoin markers

Extend recognizers to real parsers

Store the pointers of antecedence items.
One item may can be derived in different ways. Instead of collecting sets of pointers, collect sets or lists of sets of pointers (or lists of lists, whatever).

Add CFG Unger Parsing

The challenge is how to get all combinations of picking up to n items.

My idea is that: Get all numbers from 0 to 2^chartlength. From their binary representation take all with cross sum = n. Map them to the chart, 1 means the item is picked, 0 it's not. Pass the picked items to the deduction rule as always.

The next challenge is how to correctly generate consequences from them. My idea is to pass a deduction rule to the dynamic rule. And the number of antecedences has to be the number of rhs symbols. Hence n. Order the items by indices and then check if their order matches the rhs and also check if the indices match.

Make LeftCorner for CFG faster

It is so slow it is not even useable with a toy grammar.

For the returned chart allow to pass it to each item kind that interprets them and create the tree or create a new chart interpreter

Make sure that string represenations of items are not cut off if entries are empty

Allow epsilon in cfg files, too

Because why not?

Add check for sRCG

At the moment they might be RCG as well. Maybe rename the class and check for sRCG properties before parsing or converting.

In GUI when hovering over item display it as tree

It would be so cool if the text hovered over would be highlighted. It would be even cooler if parts of the items that belong together are highlighted with the same color when hovering over it.

I imagine the tree displayed in a new window that is only shown on hovering.

Maybe also display the underlying definition of the rule that was applied.

Maybe create a cursor that moves down through the whole chart, so the user gets the impression of an animated parsing process. And it takes my job of explaining. :)

CFG remove chain rules

Add CFG general CYK parsing

Implementing the Unger parsing may help to get this right, too.

sRCG binarize

and check ifBinarized()

Parse MCFG

Create Earley for TAG