コード例 #1
0
ファイル: FormulaRewriter.cs プロジェクト: zzattack/mucalc
        static MuFormula RewriteBoxDia(MuFormula form)
        {
            // We extended our grammar from the assignment by allowing regular formulas instead of single-letter actions.
            // Here, we rewrite such extended formulas to their more primitive versions for which we impemented evaluators.

            if (form is Diamond) {
                var dia = form as Diamond;
                if (dia.RegularFormula.Multiplier == "+") {
                    // <R+>f = <R><R*>f
                    var rf2 = dia.RegularFormula.Clone();
                    rf2.Multiplier = "*";
                    dia.RegularFormula.Multiplier = "";
                    dia.Formula = new Diamond(dia.RegularFormula, new Diamond(rf2, dia.Formula));
                }
                else if (dia.RegularFormula.Multiplier == "*") {
                    // <R*>f = mu X . (<R> X || f)
                    var var = new Variable(GetFreeVar());
                    dia.RegularFormula.Multiplier = "";
                    return Rewrite(new Mu(var, new Disjunction(new Diamond(dia.RegularFormula, var), dia.Formula)));
                }
                dia.Formula = Rewrite(dia.Formula);
            }

            else if (form is Box) {
                var box = form as Box;
                if (box.RegularFormula.Multiplier == "+") {
                    // [R+]f = [R][R*]f
                    var rf2 = box.RegularFormula.Clone();
                    rf2.Multiplier = "*";
                    box.RegularFormula.Multiplier = "";
                    return new Box(box.RegularFormula, new Box(rf2, box.Formula));
                }
                else if (box.RegularFormula.Multiplier == "*") {
                    // [R*]f = nu X . ([R] X && f)
                    var var = new Variable(GetFreeVar());
                    box.RegularFormula.Multiplier = "";
                    return Rewrite(new Nu(var, new Disjunction(new Box(box.RegularFormula, var), box.Formula)));
                }
                box.Formula = Rewrite(box.Formula);
            }

            // we also need to perform this on all subformulas
            else if (form is Disjunction) form = new Disjunction(Rewrite(((Disjunction)form).Left), Rewrite(((Disjunction)form).Right));
            else if (form is Conjunction) form = new Conjunction(Rewrite(((Conjunction)form).Left), Rewrite(((Conjunction)form).Right));
            else if (form is Mu) form = new Mu(((Mu)form).Variable, Rewrite(((Mu)form).Formula));
            else if (form is Nu) form = new Nu(((Nu)form).Variable, Rewrite(((Nu)form).Formula));
            else if (form is Negation) form = new Negation(Rewrite(((Negation)form).Formula));

            return form;
        }
コード例 #2
0
ファイル: MuCalculusParser.cs プロジェクト: zzattack/mucalc
        private object CreateNewObject(GOLD.Reduction r)
        {
            object result = null;

            switch ((ProductionIndex)r.Parent.TableIndex()) {
                case ProductionIndex.Nl_Newline:
                    // <nl> ::= NewLine <nl>
                    break;

                case ProductionIndex.Nl_Newline2:
                    // <nl> ::= NewLine
                    break;

                case ProductionIndex.Regform_Pipepipe:
                    // <regForm> ::= <regForm> '||' <regFormSeq>
                    result = new UnionFormula((RegularFormula)r[0].Data, (RegularFormula)r[2].Data);
                    break;

                case ProductionIndex.Regform:
                    // <regForm> ::= <regFormSeq>
                    result = r[0].Data;
                    break;

                case ProductionIndex.Regformseq_Dot:
                    // <regFormSeq> ::= <regFormSeq> '.' <regFormValue>
                    result = new SequenceFormula((RegularFormula)r[0].Data, (RegularFormula)r[2].Data);
                    break;

                case ProductionIndex.Regformseq:
                    // <regFormSeq> ::= <regFormValue>
                    result = r[0].Data;
                    break;

                case ProductionIndex.Regformvalue_Identifier:
                    // <regFormValue> ::= Identifier <Multiplier>
                    result = new SingleAction((string)r[0].Data, (string)r[1].Data);
                    break;

                case ProductionIndex.Regformvalue_Not:
                    // <regFormValue> ::= not <regForm>
                    result = new NegateAction((RegularFormula)r[1].Data);
                    break;

                case ProductionIndex.Regformvalue_Lparen_Rparen:
                    // <regFormValue> ::= '(' <regForm> ')' <Multiplier>
                    if ((string)r[3].Data != "")
                        return new NestedFormula((RegularFormula)r[1].Data, (string)r[3].Data);
                    else // small optimization
                        result = r[1].Data;
                    break;

                case ProductionIndex.Multiplier_Plus:
                    // <Multiplier> ::= '+'
                    result = "+";
                    break;

                case ProductionIndex.Multiplier_Times:
                    // <Multiplier> ::= '*'
                    result = "*";
                    break;

                case ProductionIndex.Multiplier:
                    // <Multiplier> ::=
                    result = "";
                    break;

                case ProductionIndex.Muform_Identifier:
                    // <muForm> ::= Identifier
                    result = new Proposition((string)r[0].Data);
                    break;

                case ProductionIndex.Muform_Variable:
                    // <muForm> ::= Variable
                    result = new Variable((string)r[0].Data);
                    break;

                case ProductionIndex.Muform_Lparen_Pipepipe_Rparen:
                    // <muForm> ::= '(' <muForm> '||' <muForm> ')'
                    result = new Disjunction((MuFormula)r[1].Data, (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Lparen_Ampamp_Rparen:
                    // <muForm> ::= '(' <muForm> '&&' <muForm> ')'
                    result = new Conjunction((MuFormula)r[1].Data, (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Lt_Gt:
                    // <muForm> ::= '<' <regForm> '>' <muForm>
                    result = new Diamond((RegularFormula)r[1].Data, (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Lbracket_Rbracket:
                    // <muForm> ::= '[' <regForm> ']' <muForm>
                    result = new Box((RegularFormula)r[1].Data, (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Mu_Variable_Dot:
                    // <muForm> ::= mu Variable '.' <muForm>
                    result = new Mu(new Variable((string)r[1].Data), (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Nu_Variable_Dot:
                    // <muForm> ::= nu Variable '.' <muForm>
                    result = new Nu(new Variable((string)r[1].Data), (MuFormula)r[3].Data);
                    break;

                case ProductionIndex.Muform_Not:
                    // <muForm> ::= not <muForm>
                    result = new Negation((MuFormula)r[1].Data);
                    break;

                case ProductionIndex.Muform_Lparen_Rparen:
                    result = r[1].Data as MuFormula;
                    break;

                case ProductionIndex.Line_Commentl:
                    // <Line> ::= CommentL <nl>
                    break;

                case ProductionIndex.Line:
                    // <Line> ::= <muForm> <nl>
                    var form = (MuFormula)r[0].Data;
                    FormulaRewriter.ResetFreeVars();
                    form = FormulaRewriter.Rewrite(form);
                    form.SetParents(null /* root has no parent */);
                    formulas.Add(form);
                    break;

                case ProductionIndex.Line2:
                    // <Line> ::= <nl>
                    break;

                case ProductionIndex.Lines:
                    // <Lines> ::= <Line> <Lines>
                    break;

                case ProductionIndex.Lines2:
                    // <Lines> ::=
                    break;

            } //switch

            return result;
        }
コード例 #3
0
ファイル: FormulaRewriter.cs プロジェクト: zzattack/mucalc
        // rewrite regular formulas inside box/diamond to multiple boxes/diamonds
        static MuFormula RewriteRFs(MuFormula form)
        {
            // connectives on regular formulas
            // <a.rf>f = <a><rf>f

            if (form is Box) {
                var box = form as Box;

                // [rf1+rf2]f = [rf1]f || [rf2]f
                /*if (box.RegularFormula is UnionFormula) {
                    var un = box.RegularFormula as UnionFormula;
                    return Rewrite(new Disjunction(new Box(un.Left, box.Formula), new Box(un.Right, box.Formula)));
                }*/
                // directly supported by RegularFormula now!

                // [a.rf]f = [a][rf]f
                if (box.RegularFormula is SequenceFormula) {
                    var seq = box.RegularFormula as SequenceFormula;
                    return Rewrite(new Box(seq.First, new Box(seq.Sequence, RewriteRFs(box.Formula))));
                }

                // by now all *s should be gone, so we can rewrite
                // [(a.b)] to [a.b]
                else if (box.RegularFormula is NestedFormula) {
                    var nested = box.RegularFormula as NestedFormula;
                    if (nested.Multiplier != "")
                        throw new InvalidProgramException("by now all multipliers should have been removed");
                    box.RegularFormula = nested.Inner;
                    return Rewrite(box);
                }
            }

            else if (form is Diamond) {
                var dia = form as Diamond;
                // <rf1+rf2>f = <[rf1>f || <rf2>f
                /*if (dia.RegularFormula is UnionFormula) {
                    var un = dia.RegularFormula as UnionFormula;
                    return Rewrite(new Disjunction(new Diamond(un.Left, dia.Formula), new Diamond(un.Right, dia.Formula)));
                }*/
                // directly supported now!

                // <a.rf>f = <a><rf>f
                if (dia.RegularFormula is SequenceFormula) {
                    var seq = dia.RegularFormula as SequenceFormula;
                    dia.RegularFormula = seq.First;
                    dia.Formula = new Diamond(seq.Sequence, dia.Formula);
                    return Rewrite(dia);
                }

                else if (dia.RegularFormula is NestedFormula) {
                    var nested = dia.RegularFormula as NestedFormula;
                    if (nested.Multiplier != "")
                        throw new InvalidProgramException("by now all multipliers should have been removed");
                    dia.RegularFormula = nested.Inner;
                    return Rewrite(dia);
                }
            }

            // we also need to perform this on all subformulas
            else if (form is Disjunction) form = new Disjunction(Rewrite(((Disjunction)form).Left), Rewrite(((Disjunction)form).Right));
            else if (form is Conjunction) form = new Conjunction(Rewrite(((Conjunction)form).Left), Rewrite(((Conjunction)form).Right));
            else if (form is Mu) form = new Mu(((Mu)form).Variable, Rewrite(((Mu)form).Formula));
            else if (form is Nu) form = new Nu(((Nu)form).Variable, Rewrite(((Nu)form).Formula));

            return form;
        }
コード例 #4
0
ファイル: MuCalculusParser.cs プロジェクト: zzattack/mucalc
        private object CreateNewObject(GOLD.Reduction r)
        {
            object result = null;

            switch ((ProductionIndex)r.Parent.TableIndex())
            {
            case ProductionIndex.Nl_Newline:
                // <nl> ::= NewLine <nl>
                break;

            case ProductionIndex.Nl_Newline2:
                // <nl> ::= NewLine
                break;

            case ProductionIndex.Regform_Pipepipe:
                // <regForm> ::= <regForm> '||' <regFormSeq>
                result = new UnionFormula((RegularFormula)r[0].Data, (RegularFormula)r[2].Data);
                break;

            case ProductionIndex.Regform:
                // <regForm> ::= <regFormSeq>
                result = r[0].Data;
                break;

            case ProductionIndex.Regformseq_Dot:
                // <regFormSeq> ::= <regFormSeq> '.' <regFormValue>
                result = new SequenceFormula((RegularFormula)r[0].Data, (RegularFormula)r[2].Data);
                break;

            case ProductionIndex.Regformseq:
                // <regFormSeq> ::= <regFormValue>
                result = r[0].Data;
                break;

            case ProductionIndex.Regformvalue_Identifier:
                // <regFormValue> ::= Identifier <Multiplier>
                result = new SingleAction((string)r[0].Data, (string)r[1].Data);
                break;

            case ProductionIndex.Regformvalue_Not:
                // <regFormValue> ::= not <regForm>
                result = new NegateAction((RegularFormula)r[1].Data);
                break;

            case ProductionIndex.Regformvalue_Lparen_Rparen:
                // <regFormValue> ::= '(' <regForm> ')' <Multiplier>
                if ((string)r[3].Data != "")
                {
                    return(new NestedFormula((RegularFormula)r[1].Data, (string)r[3].Data));
                }
                else                         // small optimization
                {
                    result = r[1].Data;
                }
                break;

            case ProductionIndex.Multiplier_Plus:
                // <Multiplier> ::= '+'
                result = "+";
                break;

            case ProductionIndex.Multiplier_Times:
                // <Multiplier> ::= '*'
                result = "*";
                break;

            case ProductionIndex.Multiplier:
                // <Multiplier> ::=
                result = "";
                break;

            case ProductionIndex.Muform_Identifier:
                // <muForm> ::= Identifier
                result = new Proposition((string)r[0].Data);
                break;

            case ProductionIndex.Muform_Variable:
                // <muForm> ::= Variable
                result = new Variable((string)r[0].Data);
                break;

            case ProductionIndex.Muform_Lparen_Pipepipe_Rparen:
                // <muForm> ::= '(' <muForm> '||' <muForm> ')'
                result = new Disjunction((MuFormula)r[1].Data, (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Lparen_Ampamp_Rparen:
                // <muForm> ::= '(' <muForm> '&&' <muForm> ')'
                result = new Conjunction((MuFormula)r[1].Data, (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Lt_Gt:
                // <muForm> ::= '<' <regForm> '>' <muForm>
                result = new Diamond((RegularFormula)r[1].Data, (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Lbracket_Rbracket:
                // <muForm> ::= '[' <regForm> ']' <muForm>
                result = new Box((RegularFormula)r[1].Data, (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Mu_Variable_Dot:
                // <muForm> ::= mu Variable '.' <muForm>
                result = new Mu(new Variable((string)r[1].Data), (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Nu_Variable_Dot:
                // <muForm> ::= nu Variable '.' <muForm>
                result = new Nu(new Variable((string)r[1].Data), (MuFormula)r[3].Data);
                break;

            case ProductionIndex.Muform_Not:
                // <muForm> ::= not <muForm>
                result = new Negation((MuFormula)r[1].Data);
                break;

            case ProductionIndex.Muform_Lparen_Rparen:
                result = r[1].Data as MuFormula;
                break;

            case ProductionIndex.Line_Commentl:
                // <Line> ::= CommentL <nl>
                break;


            case ProductionIndex.Line:
                // <Line> ::= <muForm> <nl>
                var form = (MuFormula)r[0].Data;
                FormulaRewriter.ResetFreeVars();
                form = FormulaRewriter.Rewrite(form);
                form.SetParents(null /* root has no parent */);
                formulas.Add(form);
                break;

            case ProductionIndex.Line2:
                // <Line> ::= <nl>
                break;

            case ProductionIndex.Lines:
                // <Lines> ::= <Line> <Lines>
                break;

            case ProductionIndex.Lines2:
                // <Lines> ::=
                break;
            }             //switch

            return(result);
        }
コード例 #5
0
        // rewrite regular formulas inside box/diamond to multiple boxes/diamonds
        static MuFormula RewriteRFs(MuFormula form)
        {
            // connectives on regular formulas
            // <a.rf>f = <a><rf>f

            if (form is Box)
            {
                var box = form as Box;

                // [rf1+rf2]f = [rf1]f || [rf2]f

                /*if (box.RegularFormula is UnionFormula) {
                 *      var un = box.RegularFormula as UnionFormula;
                 *      return Rewrite(new Disjunction(new Box(un.Left, box.Formula), new Box(un.Right, box.Formula)));
                 * }*/
                // directly supported by RegularFormula now!

                // [a.rf]f = [a][rf]f
                if (box.RegularFormula is SequenceFormula)
                {
                    var seq = box.RegularFormula as SequenceFormula;
                    return(Rewrite(new Box(seq.First, new Box(seq.Sequence, RewriteRFs(box.Formula)))));
                }

                // by now all *s should be gone, so we can rewrite
                // [(a.b)] to [a.b]
                else if (box.RegularFormula is NestedFormula)
                {
                    var nested = box.RegularFormula as NestedFormula;
                    if (nested.Multiplier != "")
                    {
                        throw new InvalidProgramException("by now all multipliers should have been removed");
                    }
                    box.RegularFormula = nested.Inner;
                    return(Rewrite(box));
                }
            }

            else if (form is Diamond)
            {
                var dia = form as Diamond;
                // <rf1+rf2>f = <[rf1>f || <rf2>f

                /*if (dia.RegularFormula is UnionFormula) {
                 *      var un = dia.RegularFormula as UnionFormula;
                 *      return Rewrite(new Disjunction(new Diamond(un.Left, dia.Formula), new Diamond(un.Right, dia.Formula)));
                 * }*/
                // directly supported now!

                // <a.rf>f = <a><rf>f
                if (dia.RegularFormula is SequenceFormula)
                {
                    var seq = dia.RegularFormula as SequenceFormula;
                    dia.RegularFormula = seq.First;
                    dia.Formula        = new Diamond(seq.Sequence, dia.Formula);
                    return(Rewrite(dia));
                }

                else if (dia.RegularFormula is NestedFormula)
                {
                    var nested = dia.RegularFormula as NestedFormula;
                    if (nested.Multiplier != "")
                    {
                        throw new InvalidProgramException("by now all multipliers should have been removed");
                    }
                    dia.RegularFormula = nested.Inner;
                    return(Rewrite(dia));
                }
            }

            // we also need to perform this on all subformulas
            else if (form is Disjunction)
            {
                form = new Disjunction(Rewrite(((Disjunction)form).Left), Rewrite(((Disjunction)form).Right));
            }
            else if (form is Conjunction)
            {
                form = new Conjunction(Rewrite(((Conjunction)form).Left), Rewrite(((Conjunction)form).Right));
            }
            else if (form is Mu)
            {
                form = new Mu(((Mu)form).Variable, Rewrite(((Mu)form).Formula));
            }
            else if (form is Nu)
            {
                form = new Nu(((Nu)form).Variable, Rewrite(((Nu)form).Formula));
            }

            return(form);
        }
コード例 #6
0
        static MuFormula RewriteBoxDia(MuFormula form)
        {
            // We extended our grammar from the assignment by allowing regular formulas instead of single-letter actions.
            // Here, we rewrite such extended formulas to their more primitive versions for which we impemented evaluators.

            if (form is Diamond)
            {
                var dia = form as Diamond;
                if (dia.RegularFormula.Multiplier == "+")
                {
                    // <R+>f = <R><R*>f
                    var rf2 = dia.RegularFormula.Clone();
                    rf2.Multiplier = "*";
                    dia.RegularFormula.Multiplier = "";
                    dia.Formula = new Diamond(dia.RegularFormula, new Diamond(rf2, dia.Formula));
                }
                else if (dia.RegularFormula.Multiplier == "*")
                {
                    // <R*>f = mu X . (<R> X || f)
                    var var = new Variable(GetFreeVar());
                    dia.RegularFormula.Multiplier = "";
                    return(Rewrite(new Mu(var, new Disjunction(new Diamond(dia.RegularFormula, var), dia.Formula))));
                }
                dia.Formula = Rewrite(dia.Formula);
            }

            else if (form is Box)
            {
                var box = form as Box;
                if (box.RegularFormula.Multiplier == "+")
                {
                    // [R+]f = [R][R*]f
                    var rf2 = box.RegularFormula.Clone();
                    rf2.Multiplier = "*";
                    box.RegularFormula.Multiplier = "";
                    return(new Box(box.RegularFormula, new Box(rf2, box.Formula)));
                }
                else if (box.RegularFormula.Multiplier == "*")
                {
                    // [R*]f = nu X . ([R] X && f)
                    var var = new Variable(GetFreeVar());
                    box.RegularFormula.Multiplier = "";
                    return(Rewrite(new Nu(var, new Disjunction(new Box(box.RegularFormula, var), box.Formula))));
                }
                box.Formula = Rewrite(box.Formula);
            }

            // we also need to perform this on all subformulas
            else if (form is Disjunction)
            {
                form = new Disjunction(Rewrite(((Disjunction)form).Left), Rewrite(((Disjunction)form).Right));
            }
            else if (form is Conjunction)
            {
                form = new Conjunction(Rewrite(((Conjunction)form).Left), Rewrite(((Conjunction)form).Right));
            }
            else if (form is Mu)
            {
                form = new Mu(((Mu)form).Variable, Rewrite(((Mu)form).Formula));
            }
            else if (form is Nu)
            {
                form = new Nu(((Nu)form).Variable, Rewrite(((Nu)form).Formula));
            }
            else if (form is Negation)
            {
                form = new Negation(Rewrite(((Negation)form).Formula));
            }

            return(form);
        }