GRAMMATICA PER QUERY SU DOCUMENTI MATEMATICI
MATHEMATICAL QUERY LANGUAGE (MathQL) 

<query> := <set>                               (* clausola iniziale *)

<set> :=  ( <set> )                            (* parentesizzazione *)
       |  <rvar>			       (* var per insieme singoletto 
						  di una risorsa *)
       |  <svar>			       (* var per insieme di risorse
						  (insieme di valori) *)
       |  REF <string-set>                     (* oggetto/i referenziato/i da 
						  URI esplicita/e *)
       |  PATTERN <string-set>                 (* oggetto/i referenziato/i da 
						  URI ottenute da espansione 
						  del pattern *)
       |  SELECT <rvar> IN <set> WHERE <bool>  (* selezione *)
       |  LET <svar> BE <set> IN <set>         (* assegnazione a set-var in 
                                                  contesto *)
       |  LET <vvar> BE <string-set> IN <set>  (* assegnamento a value-var
						  in contesto*)
       |  RELATION <refine_op> <quoted-constant-string-path> <set> ATTR <vvar-list>
       		                               (* unione insieme risorse in
						  relazione specificata con le
						  risorse in set, ognuna con 
						  attributi (ATTR) *)
       |  <set> UNION <set>                    (* unione *)
       |  <set> INTERSECT <set>                (* intersezione *)
       |  <set> DIFF <set>                     (* differenza *)

<refine_op> := ""			       (* relazione (proprieta') *)
      	    |  SUB			       (* proprieta' e 
						  sotto-proprieta' *)
	    |  SUPER			       (* proprieta' e 
						  super-proprieta' *)

<quoted-constant-string-path> := <quoted-constant-string> 
					       (* relazione (proprieta') *)
			      |  <quoted-constant-string> "/" <quoted-constant-string-path>
					       (* insieme di stringhe:
						  proprieta' strutturata *)

<vvar-list> := <vvar>
            |  <vvar> , <vvar-list>


<bool> := ( <bool> )                           (* parentesizzazione *)
       |  TRUE                                 (* vero *)
       |  FALSE                                (* falso *)
       |  NOT <bool>                           (* negazione *)
       |  <bool> AND <bool>                    (* congiunzione *)
       |  <bool> OR <bool>                     (* disgiunzione *)
       |  <string-set> EQ <string-set>         (* uguaglianza tra insiemi 
						  stringhe (case sensitive) *)
       |  <string-set> SUB <string-set>        (* operazione di sottoinsieme 
						  tra insiemi stringhe *)
       |  <string-set> MEET <string-set>       (* operazione di meet tra 
						  insiemi stringhe *)
       |  EX <bool>			       (* existential on attributes
						  of references *)
<string-set> := {}				   (* insieme vuoto*)
	     |  <quoted-constant-string>       (* stringa singoletto *)
             |  {<quoted-constant-string-list>}(* insieme stringhe *)
             |  REFOF <set>		       (* insieme riferimenti *)
             |  <rvar>.<vvar>                  (* variabile per insieme
				                  stringhe, relativa a 
					          riferimento *)
   	     |  <function> <quoted-constant-string> <string-set> 
					       (* applicazione di funzione
						  specificata a riferimento
						  o insiemi di rif. o var*)
             |  <vvar>			       (* vvar introduced by LET *)

<quoted-constant-string-list> := <quoted-constant-string>
			      |  <quoted-constant-string> , <quoted-constant-string-list>				                  
						   (* lista di stringhe *)

<function> := FUN			   (* funzione generale *)
	   |  <property>	

<property> := ATTRIBUTE	<refine-op>	   (* funzione proprieta': restituisce
					      suoi valori (anche strutturati)
					      (e delle sotto-proprieta' o 
				              super-proprieta' *)


<rvar> := @ <not-reserved-identifier>          (* variabile per riferimento *)
<vvar> := $ <not-reserved-identifier>          (* variabile per insiemi 
						  stringhe *)
<svar> := % <not-reserved-identifier>          (* variabile per insiemi 
						  riferimenti *)


- Idea di base: grammatica del linguaggio semplice e permissiva (duttile)
- MEET e' definito come "esiste almeno un elemento che appartiene 
  all'interserzione tra due insiemi"
- le stringhe sono "case sensitive" 
- la funzione non definita sull'argomento restituisce la stringa nulla
- le <rvar> si presuppongono essere istanziate come URI references costituite
  da un URI e da un fragment identifier opzionale complete; i riferimenti 
  identificano risorse 
- Precedenza operatori:
  NOT (+)  DIFF
  AND      INTERSECT
  OR  (-)  UNION
- L'ordinamento di default e' quello alfabetico crescente in base al nome 
  delle rvar
- REF aumenta performance perche' NON accede al data base (costoso).
- l'argomento di PATTERN ha sintassi di una espressione regolare 
  POSIX 1003.2-1992
- Possibile FUN (<quoted-constant-string>):
  NAME (* URIREF -> nome_oggetto *)
- MEET aumenta performance nel caso si verifichi (a in S) oppure 
  (b in S) = ({a,b} meet S) perche' valuta S una volta sola
  Il MEET codifica inoltre l'esistenziale su risorse (URI) in un certo
  insieme che soddisfa certe condizioni
- record <rvar>.<svar> serve per disambiguare nomi uguali di variabili
- Operatori (come EQ) hanno nomi abbreviati rispetto ai costrutti del 
  linguaggio
- EX verfica che la sua condizione sia vera per almeno un insieme di attributi
  associato all'URI in rvar 
- Possibili RELATION sono:
  USE con attributo POSITION (riferimenti backward) e valori MAINHYPOTHESIS, 
		    HYPOTHESIS, MAINCONCLUSION, CONCLUSION, BODY
  USEBY con attributo POSITION (riferimenti forward) e valori MAINHYPOTHESIS, 
		    HYPOTHESIS, MAINCONCLUSION, CONCLUSION, BODY
  CONSTRUCTORS
  INTHEORY con attributo ITEMTYPE (riferimenti oggetti contenuti in teorie)
  THEORYREFTO con attributo ITEMTYPE (riferimenti teorie referenti a oggetti)
- <string-set> invece di <set> come argomento di <function> poiche' la REF non
  e' piu' restrittiva su argomento/i e quindi e' inutile imporne l'uso quando
  si passano i riferimenti alle funzioni. Con <string-set> l'utente e' libero
  di passare direttamente le stringhe dei riferimenti.
- Il costrutto di ordinamento:
  <set> SORTEDBY <function> <order>   (* unione insieme ordinato secondo
                                         valore funzione e ordine *)
  <order>:= DESC                      (* ordinamento decrescente *)
         |  ASC			      (* ordinamento crescente *) 
  perde di senso nel caso di metadati, poiche' per definizione le proprieta' 
  in RDF possono essere ripetute quindi restituiscono (come anche le funzioni 
  in generale) valori multipli per ogni riferimento (ambiguita' nell'ordine)
- Possibili proprieta' (<quoted-constant-string>):
  le DC: TITLE, CONTRIBUTOR, CREATOR, PUBLISHER, SUBJECT, DESCRIPTION, DATE,
  TYPE, FORMAT, IDENTIFIER, LANGUAGE, RELATION, SOURCE, COVERAGE, RIGHTS, 
  RIGHTS; and INSTITUTION, CONTACT, FIRSTVERSION, MODIFIED, THEORY
- Il concetto di Classe, sottoclasse, superclasse, puo' essere visto come una
  particolare proprieta' (type o tipo) di una risorsa, e quindi codificabile
  da RELATION