Failing to generate S=>Ba from python code given

Question

Given S=>BaB, B=>b and null(B), the code is supposed to generate S=>BaB|aB|Ba|a and B=>b but it is not generating Ba i.e the output is S=>BaB|aB|a and B=>b which is not correct.

The code can generate values correctly if terminal is not in the middle for example S=>BBa, B=>b gives out S=>BBa|Ba|a and B=>b The only case not working is when a terminal is on the middle of a repeated null production

Other examples where null(B)

1. S=>aBa ,B=>b gives out S=>aBa|aa and B=>b

2. S=>aaB, B=>b gives out S=>aaB|aa and B=>b

grammar = ["S = B a B", "B = b"]
def remove_null_productions(grammar):
    null_productions = ["B"]
    print("Null productions: {0}".format(null_productions))
    new_productions = []

    for rule in grammar:
        if('$' in rule):
            continue
        else:
            new_productions.append(rule.split(" "))

    print("\nProductions:{0}".format(new_productions))
    for null in null_productions:

        for param in new_productions:

            if(null in param[2:]):
                temp = param[2:]
                temp.remove(null)

                if(len(temp)==0):
                    pass
                else:
                    clever_array = param[0:2]
                    for val in temp:
                        clever_array.append(val)

                    new_productions.append(clever_array)
            else:
                pass

    print("\nResultant Productions")
    for rule in new_productions:
        print(rule)
    return new_productions
remove_null_productions(grammar)

I expect the output of grammar S=>BaB and B=>b to be

Null productions: ['B']

Productions:[['S', '=', 'B', 'a', 'B'], ['B', '=', 'b']]

Resultant Productions
['S', '=', 'B', 'a', 'B']
['B', '=', 'b']
['S', '=', 'a', 'B']
['S', '=', 'B', 'a']
['S', '=', 'a']

But the output is

Null productions: ['B']

Productions:[['S', '=', 'B', 'a', 'B'], ['B', '=', 'b']]

Resultant Productions
['S', '=', 'B', 'a', 'B']
['B', '=', 'b']
['S', '=', 'a', 'B']
['S', '=', 'a']

Answer 1

The problem here is that temp.remove(null) will only remove the first instance of null in temp. Thus you end up adding 'S=>aB' but not 'S=>Ba'. You need to iterate through all symbols on the right hand side and replace each instance of the null value.

Doing this naively, however, will result in repeated productions (e.g. 'S=>aB' and 'S=>Ba' will both give 'S=>a'). You can avoid this issue by using a set to keep track of tuples of the productions already generated (tuples must be used instead of lists because items in a set must be immutable). You can then check against this set to make sure that you're not appending a production that has already been added.

Here's some working code that produces the expected output for both "S=>BaB" and "S=>BBa." I've mostly kept the code the same except for modifying the logic to add new productions. I also changed null_productions to be an argument to the function so that its value can be more readily changed.

grammar = ["S = B a B", "B = b"]
def remove_null_productions(grammar, null_productions=None):
    if null_productions is None:
        null_productions = ["B"]
    print("Null productions: {0}".format(null_productions))
    new_productions = []

    seen = set()
    for rule in grammar:
        if('$' in rule):
            continue
        else:
            new_productions.append(rule.split(" "))

    print("\nProductions:{0}".format(new_productions))
    for null in null_productions:

        for param in new_productions:
            for i, word in enumerate(param):
                if i < 2:   # don't degenerate LHS
                    continue
                if word == null:
                    temp = param[:i] + param[i+1:]
                    temp_tup = tuple(temp)
                    if len(temp) > 2 and temp_tup not in seen:
                        new_productions.append(temp)
                        seen.add(temp_tup)

    print("\nResultant Productions")
    for rule in new_productions:
        print(rule)
    return new_productions


remove_null_productions(grammar)

grammar2 = ["S = B B a", "B = b"]

remove_null_productions(grammar2)

Output for grammar:

Null productions: ['B']

Productions:[['S', '=', 'B', 'a', 'B'], ['B', '=', 'b']]

Resultant Productions
['S', '=', 'B', 'a', 'B']
['B', '=', 'b']
['S', '=', 'a', 'B']
['S', '=', 'B', 'a']
['S', '=', 'a']

Output for grammar2 (i.e. 'S=>BBa'):

Null productions: ['B']

Productions:[['S', '=', 'B', 'B', 'a'], ['B', '=', 'b']]

Resultant Productions
['S', '=', 'B', 'B', 'a']
['B', '=', 'b']
['S', '=', 'B', 'a']
['S', '=', 'a']