Mizar Language Syntax

Last modified: March 15, 2005


        Article

Article = Environment-Declaration Text-Proper .



        Environment

Environment-Declaration = "environ" { Directive } .

Directive =
   Vocabulary-Directive |
   Library-Directive |
   Requirement-Directive .

Vocabulary-Directive =
   "vocabularies" Vocabulary-Name { "," Vocabulary-Name } ";" .

Vocabulary-Name = File-Name .

Library-Directive =
   ( "notations" |
   "constructors" |
   "registrations" |
   "definitions" |
   "theorems" |
   "schemes" ) Article-Name { "," Article-Name } ";" .

Article-Name = File-Name .

Requirement-Directive = "requirements" Requirement { "," Requirement } ";" .

Requirement = File-Name .



        Text Proper

Text-Proper = Section { Section } .

Section = "begin" { Text-Item } .

Text-Item =
   Reservation |
   Definitional-Item |
   Registration-Item |
   Notation-Item |
   Theorem |
   Scheme-Item |
   Auxiliary-Item |
   Canceled-Theorem .

Reservation = "reserve" Reservation-Segment { "," Reservation-Segment } ";" .

Reservation-Segment = Reserved-Identifiers "for" Type-Expression .

Reserved-Identifiers = Identifier { "," Identifier } .

Definitional-Item = Definitional-Block ";" .

Registration-Item = Registration-Block ";" .

Notation-Item = Notation-Block ";" .

Definitional-Block =
   "definition"
      { Definition-Item | Definition }
      [ Redefinition-Block ]
   "end" .

Redefinition-Block = "redefine" { Definition-Item | Definition } .

Registration-Block =
   "registration"
      { Loci-Declaration | Cluster-Registration }
   "end" .

Notation-Block =
   "notation"
      { Loci-Declaration | Notation-Declaration }
   "end" .

Definition-Item = Loci-Declaration | Permissive-Assumption | Auxiliary-Item .

Notation-Declaration =
   Attribute-Synonym |
   Attribute-Antonym |
   Functor-Synonym |
   Mode-Synonym |
   Predicate-Synonym |
   Predicate-Antonym .

Loci-Declaration = "let" Qualified-Variables [ "such" Conditions ] ";" .

Permissive-Assumption = Assumption .

Definition =
   Structure-Definition |
   Mode-Definition |
   Functor-Definition |
   Predicate-Definition |
   Attribute-Definition |
   Canceled-Definition .

Structure-Definition =
   "struct" [ "(" Ancestors ")" ] Structure-Symbol [ "over" Loci ]
      "(#" Fields "#)" ";" .

Ancestors = Structure-Type-Expression { "," Structure-Type-Expression } .

Structure-Symbol = Symbol .

Loci = Locus { "," Locus } .

Fields = Field-Segment { "," Field-Segment } .

Locus = Variable-Identifier .

Variable-Identifier = Identifier .

Field-Segment = Selector-Symbol { "," Selector-Symbol } Specification .

Selector-Symbol = Symbol .

Specification = "->" Type-Expression .

Mode-Definition =
   "mode" Mode-Pattern ( [ Specification ] [ "means" Definiens ] ";"
      Correctness-Conditions | "is" Type-Expression ";" ) .

Mode-Pattern = Mode-Symbol [ "of" Loci ] .

Mode-Symbol = Symbol .

Mode-Synonym = "synonym" Mode-Pattern "for" Mode-Pattern ";" .

Definiens = Simple-Definiens | Conditional-Definiens .

Simple-Definiens = [ ":" Label-Identifier ":" ]
   ( Sentence | Term-Expression ) .

Label-Identifier = Identifier .

Conditional-Definiens = [ ":" Label-Identifier ":" ] Partial-Definiens-List
   [ "otherwise" ( Sentence | Term-Expression ) ] .

Partial-Definiens-List = Partial-Definiens { "," Partial-Definiens } .

Partial-Definiens = ( Sentence | Term-Expression ) "if" Sentence .

Functor-Definition = "func" Functor-Pattern [ Specification ]
   [ ( "means" | "equals" ) Definiens ] ";" Correctness-Conditions
      { Functor-Property } .

Functor-Pattern = [ Functor-Loci ] Functor-Symbol [ Functor-Loci ] |
   Left-Functor-Bracket Loci Right-Functor-Bracket .

Functor-Property =
   ( "commutativity" |
   "idempotence" |
   "involutiveness" |
   "projectivity" ) Justification ";" .

Functor-Synonym = "synonym" Functor-Pattern "for" Functor-Pattern ";" .

Functor-Loci = Locus | "(" Loci ")" .

Functor-Symbol = Symbol .

Left-Functor-Bracket = Symbol .

Right-Functor-Bracket = Symbol .

Predicate-Definition =
   "pred" Predicate-Pattern [ "means" Definiens ] ";"
       [ "correctness" Justification ";" ] { Predicate-Property } .

Predicate-Pattern = [ Loci ] Predicate-Symbol [ Loci ] .

Predicate-Property =
   ( "symmetry" |
   "asymmetry" |
   "connectedness" |
   "reflexivity" |
   "irreflexivity" ) Justification ";" .

Predicate-Synonym = "synonym" Predicate-Pattern "for" Predicate-Pattern ";" .

Predicate-Antonym = "antonym" Predicate-Pattern "for" Predicate-Pattern ";" .

Predicate-Symbol = Symbol .

Attribute-Definition = "attr" Attribute-Pattern "means" Definiens ";"
   [ "correctness" Justification ";" ] .

Attribute-Pattern = Locus "is" Attribute-Symbol .

Attribute-Synonym = "synonym" ( Attribute-Pattern | Predicate-Pattern )
   "for" Attribute-Pattern ";" .

Attribute-Antonym = "antonym" ( Attribute-Pattern | Predicate-Pattern )
   "for" Attribute-Pattern ";" .

Attribute-Symbol = Symbol .

Canceled-Definition = "canceled" [ Numeral ] ";" .

Cluster-Registration =
   Existential-Registration |
   Conditional-Registration |
   Functorial-Registration .

Existential-Registration = "cluster" Adjective-Cluster Type-Expression ";"
   Correctness-Conditions .

Adjective-Cluster = { Adjective } .

Adjective = [ "non" ] Attribute-Symbol .

Conditional-Registration =
   "cluster" Adjective-Cluster "->" Adjective-Cluster Type-Expression ";"
   Correctness-Conditions .

Functorial-Registration =
   "cluster" Term-Expression "->" Adjective-Cluster ";"
   Correctness-Conditions .

Correctness-Conditions =
   { Correctness-Condition } [ "correctness" Justification ";" ] .

Correctness-Condition =
   ( "existence" |
   "uniqueness" |
   "coherence" |
   "compatibility" |
   "consistency" ) Justification ";" .

Theorem = "theorem" Compact-Statement .

Scheme-Item = Scheme-Block ";" .

Scheme-Block =
   "scheme" Scheme-Identifier "{" Scheme-Parameters "}" ":"
   Scheme-Conclusion [ "provided" Scheme-Premise { "and" Scheme-Premise } ]
   "proof" { Reasoning-Item } "end" .

Scheme-Identifier = Identifier .

Scheme-Parameters = Scheme-Segment { "," Scheme-Segment } .

Scheme-Conclusion = Sentence .

Scheme-Premise = Proposition .

Scheme-Segment = Predicate-Segment | Functor-Segment .

Predicate-Segment =
   Predicate-Identifier { "," Predicate-Identifier }
   "[" [ Type-Expression-List ] "]" .

Predicate-Identifier = Identifier .

Functor-Segment =
   Functor-Identifier { "," Functor-Identifier }
   "(" [ Type-Expression-List ] ")" Specification .

Functor-Identifier = Identifier .

Auxiliary-Item = Statement | Private-Definition .

Canceled-Theorem = "canceled" [ Numeral ] ";" .

Private-Definition =
   Constant-Definition |
   Private-Functor-Definition |
   Private-Predicate-Definition .

Constant-Definition = "set" Equating-List ";" .

Equating-List = Equating { "," Equating } .

Equating = Variable-Identifier "=" Term-Expression .

Private-Functor-Definition =
   "deffunc" Private-Functor-Pattern "=" Term-Expression .

Private-Predicate-Definition =
   "defpred" Private-Predicate-Pattern "means" Sentence .

Private-Functor-Pattern =
   Functor-Identifier "(" [ Type-Expression-List ] ")" .

Private-Predicate-Pattern =
   Predicate-Identifier "[" [ Type-Expression-List ] "]" .

Reasoning =
   { Reasoning-Item } [ "per" "cases" Simple-Justification ";"
   ( Case-List | Suppose-List ) ] .

Case-List = Case { Case } .

Case = "case" ( Proposition | Conditions ) ";" { Reasoning-Item } "end" ";" .

Suppose-List = Suppose { Suppose } .

Suppose =
   "suppose" ( Proposition | Conditions ) ";" { Reasoning-Item } "end" ";" .

Reasoning-Item = Auxiliary-Item | Skeleton-Item .

Skeleton-Item = Generalization | Assumption | Conclusion | Exemplification .

Generalization = "let" Qualified-Variables [ "such" Conditions ] ";" .

Assumption =
   Single-Assumption |
   Collective-Assumption |
   Existential-Assumption .

Single-Assumption = "assume" Proposition ";" .

Collective-Assumption = "assume" Conditions ";" .

Existential-Assumption =
   "given" Qualified-Variables [ "such" Conditions ] ";" .

Conclusion = ( "thus" | "hence" ) Compact-Statement | Diffuse-Conclusion .

Diffuse-Conclusion = "thus" Diffuse-Statement | "hereby" Reasoning "end" ";" .

Exemplification = "take" Example { "," Example } ";" .

Example = Term-Expression | Variable-Identifier "=" Term-Expression .

Statement = [ "then" ] Linkable-Statement | Diffuse-Statement .

Linkable-Statement =
   Compact-Statement |
   Choice-Statement |
   Type-Changing-Statement |
   Iterative-Equality .

Compact-Statement = Proposition Justification ";" .

Choice-Statement =
   "consider" Qualified-Variables [ "such" Conditions ]
   Simple-Justification ";" .

Type-Changing-Statement =
   "reconsider" Type-Change-List "as"
   Type-Expression Simple-Justification ";" .

Type-Change-List = ( Equating | Variable-Identifier )
   { "," ( Equating | Variable-Identifier ) } .

Iterative-Equality =
   Term-Expression "=" Term-Expression Simple-Justification
   ".=" Term-Expression Simple-Justification
   { ".=" Term-Expression Simple-Justification } ";" .

Diffuse-Statement = [ Label-Identifier ":" ] "now" Reasoning "end" ";" .

Justification = Simple-Justification | Proof .

Simple-Justification = Straightforward-Justification | Scheme-Justification .

Proof = ( "proof" | "@proof" ) Reasoning "end" .

Straightforward-Justification = [ "by" References ] .

Scheme-Justification = "from" Scheme-Reference [ "(" References ")" ] .

References = Reference { "," Reference } .

Reference = Local-Reference | Library-Reference .

Scheme-Reference = Local-Scheme-Reference | Library-Scheme-Reference .

Local-Reference = Label-Identifier .

Local-Scheme-Reference = Scheme-Identifier .

Library-Reference =
   Article-Name ":" ( Theorem-Number | "def" Definition-Number )
   { "," ( Theorem-Number | "def" Definition-Number ) } .

Library-Scheme-Reference = Article-Name ":" "sch" Scheme-Number .

Theorem-Number = Numeral .

Definition-Number = Numeral .

Scheme-Number = Numeral .

Conditions = "that" Proposition { "and" Proposition } .

Proposition = [ Label-Identifier ":" ] Sentence .

Sentence = Formula-Expression .



        Expressions

Formula-Expression =
   "(" Formula-Expression ")" |
   Atomic-Formula-Expression |
   Quantified-Formula-Expression |
   Formula-Expression "&" Formula-Expression |
   Formula-Expression "or" Formula-Expression |
   Formula-Expression "implies" Formula-Expression |
   Formula-Expression "iff" Formula-Expression |
   "not" Formula-Expression |
   "contradiction" |
   "thesis" .

Atomic-Formula-Expression =
   [ Term-Expression-List ] Predicate-Symbol [ Term-Expression-List ] |
   Predicate-Identifier "[" [ Term-Expression-List ] "]" |
   Term-Expression "is" Adjective { Adjective } |
   Term-Expression "is" Type-Expression .

Quantified-Formula-Expression =
   "for" Qualified-Variables [ "st" Formula-Expression ]
      ( "holds" Formula-Expression | Quantified-Formula-Expression ) |
   "ex" Qualified-Variables "st" Formula-Expression .

Qualified-Variables =
   Implicitly-Qualified-Variables |
   Explicitly-Qualified-Variables |
   Explicitly-Qualified-Variables "," Implicitly-Qualified-Variables .

Implicitly-Qualified-Variables = Variables .

Explicitly-Qualified-Variables = Qualified-Segment { "," Qualified-Segment } .

Qualified-Segment = Variables Qualification .

Variables = Variable-Identifier { "," Variable-Identifier } .

Qualification = ( "being" | "be" ) Type-Expression .

Type-Expression =
   "(" Type-Expression ")" |
   Adjective-Cluster Type-Expression |
   Radix-Type .

Structure-Type-Expression =
   "(" Structure-Type-Expression ")" |
   Adjective-Cluster Structure-Symbol [ "over" Term-Expression-List ] .

Radix-Type =
   Mode-Symbol [ "of" Term-Expression-List ] |
   Structure-Symbol [ "over" Term-Expression-List ] .

Type-Expression-List = Type-Expression { "," Type-Expression } .

Term-Expression =
   "(" Term-Expression ")" |
   [ Arguments ] Functor-Symbol [ Arguments ] |
   Left-Functor-Bracket Term-Expression-List Right-Functor-Bracket |
   Functor-Identifier "(" [ Term-Expression-List ] ")" |
   Structure-Symbol "(#" Term-Expression-List "#)" |
   Variable-Identifier |
   "{" Term-Expression [ Postqualification ] ":" Sentence "}" |
   Numeral |
   Term-Expression "qua" Type-Expression |
   "the" Selector-Symbol "of" Term-Expression |
   "the" Selector-Symbol |
   Private-Definition-Parameter |
   "it" .

Arguments = Term-Expression | "(" Term-Expression-List ")" .

Term-Expression-List = Term-Expression { "," Term-Expression } .

Postqualification =
   "where" Postqualifying-Segment { "," Postqualifying-Segment } .

Postqualifying-Segment =
   Postqualified-Variable { "," Postqualified-Variable } "is"
   Type-Expression .

Postqualified-Variable = Identifier .

Private-Definition-Parameter =
   "$1" | "$2" | "$3" | "$4" | "$5" | "$6" | "$7" | "$8" | "$9" | "$10" .
