Overview: Mathematical Markup Language (MathML) Version 2.0
Previous: A Parsing MathML
Next: C Content Element Definitions
B Content Markup Validation Grammar
Informal EBNF grammar for Content Markup structure validation ============================================================= // Notes // // This defines the valid expression trees in content markup // // ** it does not define attribute validation - // ** this has to be done on top // // Presentation_tags is a placeholder for a valid // presentation element start tag or end tag // // #PCDATA is the XML parsed character data // // symbols beginning with '_' for example _mmlarg are internal symbols // (recursive grammar usually required for recognition) // // all-lowercase symbols for example 'ci' are terminal symbols // representing MathML content elements // // symbols beginning with Uppercase are terminals // representating other tokens // // revised sb 3.nov.97, 16.nov.97 and 22.dec.1997 // revised sb 6.jan.98, 6.Feb.1998 and 4.april.1998 // revised sb 27.nov.2000 for MathML2.0 // // whitespace definitions including presentation_tags Presentation_tags ::= "presentation" //placeholder Space ::= #x09 | #xoA | #xoD | #x20 //tab, lf, cr, space characters S ::= (Space | Presentation_tags)* //treat presentation as space // only for content validation // characters Char ::= Space | [#x21 - #xFFFD] | [#x00010000 - #x7FFFFFFFF] //valid XML chars // start and end tag functions // start(\%x) returns a valid start tag for the element \%x // end(\%x) returns a valid end tag for the element \%x // empty(\%x) returns a valid empty tag for the element \%x // // start(ci) ::= "<ci>" // end(cn) ::= "</cn>" // empty(plus) ::= "<plus/>" // // The reason for doing this is to avoid writing a grammar // for all the attributes. The model below is not complete // for all possible attribute values. _start(\%x) ::= "<\%x" (Char - '>')* ">" // returns a valid start tag for the element \%x _end(\%x) ::= "<\%x" Space* ">" // returns a valid end tag for the element \%x _empty(\%x) ::= "<\%x" (Char - '>')* "/>" // returns a valid empty tag for the element \%x _sg(\%x) ::= S _start(\%x) // start tag preceded by optional whitespace _eg(\%x) ::= _end(\%x) S // end tag followed by optional whitespace _ey(\%x) ::= S _empty(\%x) S // empty tag preceded and followed by optional whitespace // mathml content constructs _mmlall ::= _container | _relation | _operator | _qualifier | _other _mmlarg ::= _container _container ::= _token | _special | _constructor _token ::= ci | cn | csymbol | _constantsym _special ::= apply | lambda | reln | fn _constructor ::= interval | list | matrix | matrixrow | set | vector | piecewise | piece | otherwise _other ::= condition | declare | sep _qualifier ::= lowlimit | uplimit | bvar | degree | logbase | domainofapplication | momentabout _constantsym ::= integers | rationals | reals | naturalnumbers | complexes | primes | exponentiale | imaginaryi | notanumber | true | false | pi | eulergamma | infinity // relations _relation ::= _genrel | _setrel | _seqrel2ary _genrel ::= _genrel2ary | _genrelnary _genrel2ary ::= ne _genrelnary ::= eq | leq | lt | geq | gt _setrel ::= _seqrel2ary | _setrelnary _setrel2ary ::= in | notin | notsubset | notprsubset _setrelnary ::= subset | prsubset _seqrel2ary ::= tendsto //operators _operator ::= _funcop | _sepop | _arithop | _calcop | _vcalcop | _seqop | _trigop | _classop | _statop | _lalgop | _logicop | _setop //functional operators _funcop ::= _funcop1ary | _funcopnary _funcop1ary ::= inverse | ident | domain | codomain | image _funcopnary ::= fn| compose // general user-defined function is n-ary // arithmetic operators // (note minus is both 1ary and 2ary) _arithop ::= _arithop1ary | _arithop2ary | _arithopnary | root _arithop1ary ::= abs | conjugate | factorial | minus | arg | real | imaginary | floor | ceiling _arithop2ary ::= quotient | divide | minus | power | rem _arithopnary ::= plus | times | max | min | gcd | lcm // calculus and vector calculus _calcop ::= int | diff | partialdiff _vcalcop ::= divergence | grad | curl | laplacian // sequences and series _seqop ::= sum | product | limit // elementary classical functions and trigonometry _classop ::= exp | ln | log _trigop ::= sin | cos | tan | sec | csc | cot | sinh | cosh | tanh | sech | csch | coth | arcsin | arccos | arctan // statistics operators _statop ::= _statopnary | moment _statopnary ::= mean | sdev | variance | median | mode // linear algebra operators _lalgop ::= _lalgop1ary |_lalgop2ary | _lalgopnary _lalgop1ary ::= determinant | transpose _lalgop2ary ::= vectorproduct | scalarproduct | outerproduct _lalgopnary ::= selector // logical operators _logicop ::= _logicop1ary | _logicopnary | _logicop2ary | _logicopquant _logicop1ary ::= not _logicop2ary ::= implies | equivalent | approx | factorof _logicopnary ::= and | or | xor _logicopquant ::= forall | exists // set theoretic operators _setop ::= _setop1ary |_setop2ary | _setopnary _setop1ary ::= card _setop2ary ::= setdiff _setopnary ::= union | intersect | cartesianproduct // operator groups _unaryop ::= _func1ary | _arithop1ary | _trigop | _classop | _calcop | vcalcop | _logicop1ary | _lalgop1ary | setop1ary _binaryop ::= _arithop2ary | _setop2ary | _logicop2ary | _lalgop2ary _naryop ::= _arithopnary | _statopnary | _logicopnary | _lalgopnary | _setopnary | _funcopnary _ispop ::= int | sum | product _diffop ::= diff | partialdiff _binaryrel ::= _genrel2ary | _setrel2ary | _seqrel2ary _naryrel ::= _genrelnary | _setrelnary //separator sep ::= _ey(sep) // leaf tokens and data content of leaf elements // note _mdata includes Presentation constructs here. _mdatai ::= (#PCDATA | Presentation_tags)* _mdatan ::= (#PCDATA | sep | Presentation_tags)* ci ::= _sg(ci) _mdatai _eg(ci) cn ::= _sg(cn) _mdatan _eg(cn) csymbol ::= _sg(csymbol) _mdatai _eg(csymbol) // condition - constraints constraints. contains either // a single reln (relation), or // an apply holding a logical combination of relations, or // a set (over which the operator should be applied) condition ::= _sg(condition) reln | apply | set _eg(condition) // domains for integral, sum , product _ispdomain ::= (lowlimit uplimit?) | uplimit | interval | condition // apply construct // Note that apply is used in place of the deprecated reln in MathML2.0 // for relational operators as well as arithmetic, algebraic etc. // apply ::= _sg(apply) _applybody | _relnbody _eg(apply) _applybody ::= ( _unaryop _mmlarg ) //1-ary ops | (_binaryop _mmlarg _mmlarg) //2-ary ops | (_naryop _mmlarg*) //n-ary ops, enumerated arguments | (_naryop bvar* condition _mmlarg) //n-ary ops, condition defines argument list | (_ispop bvar? _ispdomain? _mmlarg) //integral, sum, product | (_ispop domainofapplication? _mmlarg) //integral, sum, product | (_diffop bvar* _mmlarg) //differential ops | (log logbase? _mmlarg) //logs | (moment degree? momentabout? _mmlarg*) //statistical moment | (root degree? _mmlarg) //radicals - default is square-root | (limit bvar* lowlimit? condition? _mmlarg) //limits | (_logicopquant bvar+ condition? (reln | apply)) //quantifier with explicit bound variables // equations and relations - reln uses lisp-like syntax (like apply) // the bvar and condition are used to construct a "such that" or // "where" constraint on the relation . // Note that reln is deprecated but still valid in MathML2.0 reln ::= _sg(reln) _relnbody _eg(reln) _relnbody ::= ( _binaryrel bvar* condition? _mmlarg _mmlarg ) | ( _naryrel bvar* condition? _mmlarg* ) // fn construct // Note that fn is deprecated but still valid in MathML2.0 fn ::= _sg(fn) _fnbody _eg(fn) _fnbody ::= Presentation_tags | container // lambda construct - note at least 1 bvar must be present lambda ::= _sg(lambda) _lambdabody _eg(lambda) _lambdabody ::= bvar+ _container //multivariate lambda calculus //declare construct declare ::= _sg(declare) _declarebody _eg(declare) _declarebody ::= ci (fn | constructor)? // constructors interval ::= _sg(interval) _mmlarg _mmlarg _eg(interval) //start, end define interval set ::= _sg(set) _lsbody _eg(set) list ::= _sg(list) _lsbody _eg(list) _lsbody ::= _mmlarg* //enumerated arguments | (bvar* condition _mmlarg) //condition constructs arguments matrix ::= _sg(matrix) matrixrow* _eg(matrix) matrixrow ::= _sg(matrixrow) _mmlall* _eg(matrixrow) //allows matrix of operators vector ::= _sg(vector) _mmlarg* _eg(vector) piecewise ::= _sg(piecewise) piece* otherwise? _eg(piecewise) piece ::= _sg(piece) _mmlall _eg(piece) //allows piecewise construct of operators otherwise ::= _sg(otherwise) _mmlall _eg(otherwise) //allows piecewise construct of operators //qualifiers - note the contained _mmlarg could be a reln lowlimit ::= _sg(lowlimit) _mmlarg _eg(lowlimit) uplimit ::= _sg(uplimit) _mmlarg _eg(uplimit) bvar ::= _sg(bvar) ci degree? _eg(bvar) degree ::= _sg(degree) _mmlarg _eg(degree) logbase ::= _sg(logbase) _mmlarg _eg(logbase) domainofapplication ::= _sg(domainofapplication) _mmlarg _eg(domainofapplication) momentabout ::= _sg(momentabout) _mmlarg _eg(momentabout) //relations and operators and constant symbols // (one declaration for each operator and relation element) _relation ::= _ey(\%relation) //for example <eq/> <lt/> _operator ::= _ey(\%operator) //for example <exp/> <times/> _const-symbol ::= _ey(\%const-symbol) //for example <integers/> <false/> //the top level math element //allow declare only at the head of a math element. math ::= _sg(math) declare* mmlall* _eg(math)
Overview: Mathematical Markup Language (MathML) Version 2.0
Previous: A Parsing MathML
Next: C Content Element Definitions