import { Heading, Strikethrough, UAnnotation as U } from '@steffo/bluelib-react'
import type { NextPage, NextPageContext } from 'next'
import { Link } from '../../../components/link'
import { Box, Split, r, Help, Color, Code, I, Todo, B, LI, Anchor, P, Aside, LatexMath } from "../../../components/compat-old"
import tokenStyle from "./tokenStyle.module.css"
import Image from "next/image"


export async function getStaticProps(_context: NextPageContext) {
    return {
        props: {}
    }
}


const Token = ({ children = undefined, indexTerm = undefined, stopword = undefined }: any) => {
    if(indexTerm) {
        return (
            <B builtinColor='yellow'><span className={tokenStyle.token}>{children}</span></B>
        )
    }

    if(stopword) {
        return (
            <Strikethrough builtinColor='red'><span className={tokenStyle.token}>{children}</span></Strikethrough>
        )
    }

    return (
        <span className={tokenStyle.token}>{children}</span>
    )
}
const API = () => <Help text={"Application Programming Interface, fonti di dati fruibili attraverso HTTP"}>API</Help>
const Glob = () => <Help text={`La sintassi della ricerca tra file, dove ? sostituisce un singolo carattere, * un qualsiasi numero e ** include le sottocartelle.`}
>Glob</Help>
const IC = () => <Help text={`Information content, self-information, surprisal, Shannon information`}>IC</Help>
const IDF = () => <Help text={"Inverse document frequency, quanto un termine è raro all'interno della collezione di documenti"}><LatexMath>{`idf`}</LatexMath></Help>
const IR = () => <Help text={"Information Retrieval, il nome stesso del corso"}>IR</Help>
const Locuzione = () => <Help text={`Gruppo di parole che funzionano come una unica: a cavallo, forze dell'ordine, etc.`}>locuzione</Help>
const Omonimi = () => <Help text={"Parole che si leggono e scrivono nello stesso ma significano cose diverse."}>Omonimi</Help>
const Predicato = () => <Help text={"La minima unità booleana valutabile. `A`, `B`, etc. Equivalente a un evento in statistica, e a una variabile in matematica."}>predicato</Help>
const RSV = () => <Help text={"Retrieval Status Value, il punteggio assegnato ai documenti dal modello Okapi BM25"}>RSV</Help>
const Regex = () => <Help text={`Regular expressions, espressioni regolari, come /libr[oi]/ o /g.+o/`}>Regex</Help>
const TF = () => <Help text={"Term frequency, quanto un termine è frequente nel singolo documento"}><LatexMath>{`tf`}</LatexMath></Help>
const TFIDF = () => <Help text={"Metodo per calcolare i pesi che moltiplica il peso tf per il peso idf."}>tf-idf</Help>
const UIN = () => <Help text={`User Information Need, una descrizione in linguaggio naturale delle informazioni di cui ha bisogno l'utente`}>UIN</Help>


const Page: NextPage = () => {
    return <>
        <Heading level={2}>
            <Link href="/year3/gestione">
                Gestione dell&apos;informazione
            </Link>
        </Heading>
        <Split title={"Information Retrieval"}>
            <Box title={"Cos'è?"}>
                <P>
                    È il <B>processo</B> di <B>raccolta documenti</B>, <B>elaborazione query</B> e <B>richiamo di più risposte</B>.
                </P>
                <P>
                    Un&apos;applicazione che effettua <IR/> si chiama <B>motore di ricerca</B>.
                </P>
            </Box>
        </Split>
        <Split>
            <Box title={"Documenti"}>
                <P>
                    Sono le unità con cui lavora il motore di ricerca.
                </P>
                <P>
                    Possono essere di vario tipo: <B>pagine web</B>, <B>metadati di file</B>, <B>paper accademici</B>...
                </P>
                <Aside>
                    <p>
                        Ad esempio, i documenti di <Anchor href={"https://google.com"}>Google Search</Anchor> sono le <B>pagine web</B>.
                    </p>
                    <Image src={"/images/year3/gestione/documents.png"} alt={"I documenti di Google per il dominio steffo.eu"} width={297} height={112}/>
                </Aside>
                <P>
                    Vengono raccolti in svariati modi: possono provenire da <B><API/></B>, essere forniti manualmente e poi processati con un <B>parser</B>, essere scoperti tramite <B>web crawling</B> e processati tramite <B>web scraping</B>...
                </P>
                <Aside>
                    Il web crawler più famoso è <Anchor href={"https://it.wikipedia.org/wiki/Googlebot"}>Googlebot</Anchor>, che visita ricorsivamente tutti i collegamenti presenti su ogni pagina.
                </Aside>
                <P>
                    Un insieme di documenti è detto <B><I>collezione</I></B>.
                </P>
            </Box>
            <Box title={"Query"}>
                <P>
                    La <B>richiesta di informazioni</B> effettuata da un utente, in un <B>linguaggio</B> che il motore di ricerca è <B>in grado di capire</B>.
                </P>
                <Aside>
                    <p>
                        In pratica, è quello che scrivi sulla casella di ricerca di Google!
                    </p>
                    <Image src={"/images/year3/gestione/query.png"} alt={"Un esempio di query su Google"} width={297} height={143}/>
                </Aside>
                <P>
                    Solitamente vi è possibile inserire <B>parole chiave</B> e <B>operatori</B> per specificare cosa
                    si desidera trovare.
                </P>
                <Aside>
                    È possibile vedere tutti gli operatori supportati da Google nella pagina <Anchor
                    href={"https://www.google.it/advanced_search"}
                >Advanced Search</Anchor>.
                </Aside>
            </Box>
            <Box title={"Risposte"}>
                <P>
                    I <B>documenti</B> che il motore di ricerca sceglie di mostrare all&apos;utente in quanto li ha
                    ritenuti <B>rilevanti alla query effettuata</B>.
                </P>
                <P>
                    Spesso sono composte da <B>metadati del documento</B> e da un <B>breve estratto</B> della
                    sezione del documento più rilevante.
                </P>
                <Aside>
                    <p>
                        Google Search mostra <B>URL</B>, <B>titolo</B> e <B>descrizione</B> della pagina (o un
                        suo <B>estratto</B> se una descrizione non è disponibile).
                    </p>
                    <Image src={"/images/year3/gestione/result.png"} alt={"Una risposta di Google"} width={297} height={80}/>
                </Aside>
            </Box>
        </Split>
        <Split>
            <Box title={"Token"}>
                <P>
                    Astrazione che rappresenta un <B>singolo significato</B> di una parola o <Locuzione/>.
                </P>
                <Aside>
                    <P>
                        Sono token:
                    </P>
                    <ul>
                        <LI><Token>mela 🍎</Token></LI>
                        <LI><Token>ciao 👋</Token></LI>
                        <LI><Token>forze dell&apos;ordine 👮</Token></LI>
                        <LI>...</LI>
                    </ul>
                </Aside>
            </Box>
            <Box title={<span><LatexMath>{`q`}</LatexMath>-grammi</span>}>
                <P>
                    <B>Sequenze</B> di <B><LatexMath>{`q`}</LatexMath> caratteri</B> e <B>spazi vuoti</B> (indicati con ␣).
                </P>
                <Aside>
                    <P>
                        I <LatexMath>{`q`}</LatexMath>-grammi assumono vari nomi in base al valore
                        di <LatexMath>{`q`}</LatexMath>:
                    </P>
                    <ul>
                        <LI><U>Bigrammi</U>: <LatexMath>{`q = 2`}</LatexMath></LI>
                        <LI><U>Trigrammi</U>: <LatexMath>{`q = 3`}</LatexMath></LI>
                        <LI><U>Quadrigrammi</U>: <LatexMath>{`q = 4`}</LatexMath></LI>
                        <LI>...</LI>
                    </ul>
                </Aside>
                <Aside>
                    <P>
                        I trigrammi del token <Token>ciao</Token> sono:
                    </P>
                    <P>
                        <Token>␣␣c</Token> <Token>␣ci</Token> <Token>cia</Token> <Token>iao</Token> <Token>ao␣</Token> <Token>o␣␣</Token>
                    </P>
                </Aside>
            </Box>
        </Split>
        <Split title={"Preprocessing dei documenti"}>
            <Box title={"Cos'è?"}>
                <P>
                    Una <B>procedura</B> svolta quando un documento viene <B>aggiunto</B> al motore di ricerca, permettendone l&apos;indicizzazione e in seguito il richiamo.
                </P>
                <P>
                    È suddivisa in varie fasi, generalmente 5 o 6.
                </P>
            </Box>
        </Split>
        <Split>
            <Box title={"1. Analisi lessicale"}>
                <P>
                    Tutte le parole del documento vengono trasformate in <B>token</B>.
                </P>
                <Aside>
                    Treno per Modena → <Token>Treno</Token> <Token>per</Token> <Token>Modena</Token>
                </Aside>
                <P>
                    Spesso si decide di <B>distinguere</B> tra gli <B><Omonimi/></B> attraverso algoritmi di <B><I>word sense disambiguation</I></B>, in grado di dedurre il contesto analizzando i significati delle
                    parole circostanti.
                </P>
                <Aside>
                    <Token>Sale 🧂</Token> oppure <Token>Sale 🪜</Token>?
                </Aside>
            </Box>
            <Box title={"2. Normalizzazione dei token"}>
                <P>
                    Il motore di ricerca decide come trattare i <B>simboli</B> tipografici, la <B><Help text={"Quello che in inglese si chiama 'case'. Sono grafie il maiuscolo, il minuscolo, il corsivo..."}>grafia</Help></B> delle lettere, le <B>cifre</B>, modificando l&apos;insieme di token come ritiene necessario.
                </P>
                <Aside>
                    <P>
                        Alcune possibili modifiche:
                    </P>
                    <ul>
                        <LI>
                            Rimozione degli accenti
                            <Aside>
                                <Token>caffè</Token> → <Token>caffe</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Rimozione maiuscole non-significative:
                            <Aside>
                                <Token>Treno</Token> <Token>per</Token> <Token>Modena</Token> → <Token>treno</Token> <Token>per</Token> <Token>Modena</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Separazione dei trattini
                            <Aside>
                                <Token>state-of-the-art</Token> → <Token>state</Token> <Token>of</Token> <Token>the</Token> <Token>art</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Correzione dei typo
                            <Aside>
                                <Token>vetr</Token> → <Token>vetro</Token>
                            </Aside>
                        </LI>
                    </ul>
                </Aside>
            </Box>
            <Box title={"3. Eliminazione delle stopwords"}>
                <P>
                    Le <I>stopwords</I>, i token ritenuti <B>inutili</B> ai fini delle ricerche, vengono <B>eliminate</B> dall&apos;insieme di token ottenuto nel passo precedente.
                </P>
                <P>
                    Stopwords comuni sono gli <B><Help text={"Il, lo, la, un, una..."}>articoli</Help></B>, le <B><Help text={"E, perchè, ma, così..."}>congiunzioni</Help></B> e, in generale, tutte le <B>parole più frequenti</B> di una lingua.
                </P>
                <Aside>
                    <Token>basi</Token> <Token stopword={true}>di</Token> <Token>dati</Token>
                </Aside>
                <P>
                    Talvolta capita di dover <B>distinguere</B> tra stopwords e <B>nomi propri</B>, soprattutto
                    nell&apos;inglese; per risolvere il problema ci si affida alla disambiguazione degli Omonimi
                    effettuata durante l&apos;analisi lessicale.
                </P>
                <Aside>
                    La band <Anchor href={"https://en.wikipedia.org/wiki/The_Who"}>The Who</Anchor> è l&apos;incubo dei
                    motori di ricerca che eliminano indiscriminatamente le stopwords:
                    <Aside>
                        <Token stopword={true}>The</Token> <Token stopword={true}>Who</Token>
                    </Aside>
                </Aside>
            </Box>
        </Split>
        <Split>
            <Box title={"4. Stemming / Lemmatizzazione"}>
                <P>
                    Ai token del passo precedente vengono sostituite le <B>radici</B> (<I>stems</I>) oppure le <B>forme base</B> (<I>lemmas</I>) delle parole.
                </P>
                <Aside>
                    <P>
                        Alcune delle operazioni di <B>stemming</B> che possono essere effettuate sono:
                    </P>
                    <ul>
                        <LI>
                            Plurale → Singolare
                            <Aside>
                                <Token>flowers</Token> → <Token>flower</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Verbo → Infinito
                            <Aside>
                                <Token>goes</Token> → <Token>go</Token>
                            </Aside>
                        </LI>
                    </ul>
                </Aside>
                <Aside>
                    <P>
                        Alcune delle operazioni di <B>lemmatizzazione</B> che possono essere effettuate sono:
                    </P>
                    <ul>
                        <LI>
                            Plurale → Singolare
                            <Aside>
                                <Token>fiori</Token> → <Token>fiore</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Verbo → Infinito
                            <Aside>
                                <Token>vado</Token> → <Token>andare</Token>
                            </Aside>
                        </LI>
                    </ul>
                </Aside>
                <P>
                    Gli algoritmi che realizzano questo passo sono detti rispettivamente <B><I>stemmer</I></B> o <B><I>lemmatizer</I></B>.
                </P>
                <Aside>
                    Generalmente sono implementati tramite <Help text={"Dizionari che associano ogni parola alla sua forma base."}>lookup tables</Help>, ma i motori di ricerca più avanzati <Anchor href={"https://en.wikipedia.org/wiki/Stemming#Algorithms"}>possono avere implementazioni anche più complesse</Anchor>.
                </Aside>
            </Box>
            <Box title={"5. Selezione degli index term"}>
                <P>
                    Il motore di ricerca stabilisce la <B>relativa importanza</B> di ciascun token dell&apos;insieme, in modo da determinare più facilmente in seguito la rilevanza del documento in cui si trovano.
                </P>
                <P>
                    I termini più importanti di un documento sono detti <B><I>index term</I></B>.
                </P>
                <Aside>
                    <Token>appunti</Token> <Token>universitari</Token> → <Token indexTerm={true}>appunti</Token> <Token>universitari</Token>
                </Aside>
                <P>
                    Essi solitamente sono individuati da <B><I>parser</I></B> e <B><I>scanner</I></B>, che
                    analizzano la semantica di ciascun token.
                </P>
            </Box>
            <Box title={"6. Categorizzazione"}>
                <P>
                    Opzionalmente, l&apos;intero documento può essere inserito in una o più <B>categorie</B> di un <B><I>thesaurus</I></B>, una gerarchia predeterminata di categorie di documenti.
                </P>
                <Aside>
                    Un esempio di thesaurus per delle sculture:
                    <ul>
                        <LI>
                            [Radice]
                            <ul>
                                <LI>
                                    Materiale
                                    <ul>
                                        <LI>
                                            Legno
                                            <ul>
                                                <LI>Pino</LI>
                                                <LI>Betulla</LI>
                                                <LI>Mogano</LI>
                                            </ul>
                                        </LI>
                                        <LI>
                                            Pietra
                                        </LI>
                                    </ul>
                                </LI>
                                <LI>
                                    Forma
                                    <ul>
                                        <LI>Cubica</LI>
                                        <LI>Sferica</LI>
                                        <LI>Umanoide</LI>
                                    </ul>
                                </LI>
                            </ul>
                        </LI>
                    </ul>
                </Aside>
                <Aside>
                    Un (simil-)thesaurus generale per l&apos;inglese è <Anchor
                    href={"https://wordnet.princeton.edu/"}
                >WordNet</Anchor>, mentre uno per l&apos;italiano è <Anchor
                    href={"https://thes.bncf.firenze.sbn.it/thes-dati.htm"}
                >Nuovo soggettario</Anchor>.
                </Aside>
            </Box>
        </Split>
        <Split title={"Similitudine"}>
            <Box title={"Cos'è?"}>
                <P>
                    Una <B>misura</B> di quanto due token hanno <B>significati in comune</B>.
                </P>
                <Aside>
                    <P>
                        <Token>uccello</Token> e <Token>pennuto</Token> sono molto simili, in quanto sono sinonimi
                    </P>
                    <P>
                        <Token>merlo</Token> e <Token>piccione</Token> sono abbastanza simili, in quanto sono entrambi uccelli, ma non sono sinonimi
                    </P>
                    <P>
                        <Token>merlo</Token> e <Token>ala</Token> non sono per niente simili
                    </P>
                </Aside>
                <P>
                    Generalmente si basa su un <B>thesaurus</B>.
                </P>
            </Box>
            <Box title={"A cosa serve?"}>
                <P>
                    La <B><I>word sense disambiguation</I></B> sfrutta la <B>similitudine</B> tra l&apos;ononimo e i <B>token circostanti</B> per stabilire il significato corretto.
                </P>
                <P>
                    Talvolta alla similitudine sono aggiunte anche altre informazioni, come la <B>distanza</B> tra i token e dati provenienti da <B>sorgenti esterne</B>.
                </P>
            </Box>
        </Split>
        <Split>
            <Box title={"Similitudine path-based"}>
                <P>
                    Un modo di misurare la similitudine tra due token basato sulla loro <B>posizione</B> all&apos;interno del <B>thesaurus</B>.
                </P>
                <Split>
                    <Box title={"Path-distance"}>
                        <P>
                            Si basa sull&apos;<B>inverso della distanza</B> tra i due token all&apos;interno dell&apos;albero:
                        </P>
                        <B><LatexMath
                            block={true}
                        >{`sim_{pd}(t_1, t_2) = \\frac{1}{dist(t_1, t_2) + 1}`}</LatexMath></B>
                    </Box>
                    <Box title={"Wu-Palmer"}>
                        <P>
                            Si basa sulla <B>profondità</B> del <B>minimo antenato comune</B> tra i due token:
                        </P>
                        <B><LatexMath
                            block={true}
                        >{`sim_{wp}(t_1, t_2) = 2 \\cdot \\frac{depth(mac_{\\ t_1,t_2})}{depth(t_1) + depth(t_2)}`}</LatexMath></B>
                        <Aside>
                            Varia più lentamente rispetto alla Path-distance.
                        </Aside>
                    </Box>
                </Split>
            </Box>
        </Split>
        <Split>
            <Box title={<span>Similitudine <IC/>-based</span>}>
                <P>
                    L&apos;<IC/> è una misura <B>probabilistica</B> di quanto un token sia inaspettato all&apos;interno di un documento.
                </P>
                <P>
                    Definendo <LatexMath>{`P(t)`}</LatexMath> come la probabilità che un <B>token scelto a caso</B> sia <LatexMath>{`t`}</LatexMath>, l&apos;<IC/> sarà:
                </P>
                <B><LatexMath block={true}>{`ic(t) = - \\log \\left( P(t) \\right)`}</LatexMath></B>
                <P>
                    La <I>similitudine <IC/>-based</I> è quindi un modo di misurare la similitudine basato
                    sull&apos;<B><IC/></B>.
                </P>
                <Aside>
                    Le misure <IC/>-based tengono quindi conto della frequenza dei vari token nella collezione.
                </Aside>
                <Box title={"Resnik"}>
                    <P>
                        Si basa sull&apos;<B><IC/></B> del <B>minimo antenato comune</B>:
                    </P>
                    <B><LatexMath
                        block={true}
                    >{`sim_{r} (t_1,t_2) = ic \\left( mac_{\\ t_1,t_2} \\right)`}</LatexMath></B>
                </Box>
            </Box>
        </Split>
        <Split title={"Correzione dei typo"}>
            <Box title={"Cos'è?"}>
                <P>
                    Una parte della <B>normalizzazione dei token</B> che corregge gli errori ortografici commessi
                    durante l&apos;inserimento della query.
                </P>
            </Box>
            <Box title={"A cosa serve?"}>
                <P>
                    Aumenta la <B>soddisfazione</B> dell&apos;utente e gli consente di effettuare ricerche per termini di
                    cui <B>non conosce lo spelling</B>.
                </P>
            </Box>
        </Split>
        <Box title={"Correzione token isolati"}>
            <P>
                È possibile trovare per ogni token dei suoi <I>vicini</I> utilizzabili per migliorare la query:
            </P>
            <Box title={"Tramite edit distance"}>
                <P>
                    Dato un token, si cercano tutti i token <B>entro un certo valore</B> di <I>edit distance</I>.
                </P>
                <Box title={"Edit distance"}>
                    <P>
                        Il numero <B>minimo</B> di <I>operazioni</I> per convertire un token in un altro.
                    </P>
                    <Split>
                        <Box title={"Levenshtein distance"}>
                            <P>
                                Definisce <I>operazioni</I> le seguenti azioni:
                            </P>
                            <ul>
                                <LI><B>Inserimento</B> di un singolo carattere</LI>
                                <LI><B>Rimozione</B> di un singolo carattere</LI>
                                <LI><B>Sostituzione</B> di un singolo carattere</LI>
                            </ul>
                            <Aside>
                                La distanza di Levenshtein tra <Token>pierta</Token> e <Token>pietra</Token> è 2.
                            </Aside>
                            <Box title={"Matrice di distanza"}>
                                <P>
                                    Matrice costruita per calcolare la distanza di Levenshtein con un algoritmo greedy:
                                </P>
                                <Aside>
                                    <Anchor href={"https://gist.github.com/Steffo99/ceeb7ed61a7b6a12a783232c0230ce70"}>Guarda
                                        un esempio documentato in Python qui!</Anchor>
                                </Aside>
                            </Box>
                        </Box>
                        <Box title={"Damerau-Levenshtein distance"}>
                            <P>
                                Estende la distanza di Levenshtein con una nuova operazione:
                            </P>
                            <ul>
                                <LI><B>Trasposizione</B> di un singolo carattere</LI>
                            </ul>
                            <Aside>
                                La distanza di Damerau-Levenshtein tra <Token>pierta</Token> e <Token>pietra</Token> è 1.
                            </Aside>
                        </Box>
                        <Box title={"Weighted distance"}>
                            <P>
                                Differenzia i costi delle varie operazioni, diffenenziando ad esempio in base al carattere sostituito.
                            </P>
                            <Aside>
                                <code>m</code> ed <code>n</code> sono vicini sulla tastiera e quindi la loro sostituzione &quot;costa&quot; meno, rispetto a <code>q</code> e <code>p</code>.
                            </Aside>
                        </Box>
                    </Split>
                    <P>
                        Calcolare l&apos;edit distance <LatexMath>{`E`}</LatexMath> tra due token è un processo computazionalmente <B>molto costoso <LatexMath>{`O(n^2)`}</LatexMath></B>.
                    </P>
                    <Box title={"Pre-filtraggio"}>
                        <P>
                            È possibile evitare di calcolare l&apos;edit distance per la maggior parte dei termini del
                            vocabolario <I>pre-filtrandoli</I> su <B>criteri computazionalmente più veloci</B>.
                        </P>
                        <Split>
                            <Box title={"Differenza di lunghezza"}>
                                <Aside>
                                    L&apos;edit distance come minimo è la differenza tra il numero di caratteri dei due
                                    token.
                                </Aside>
                                <B><LatexMath block={true}>{r`E \geq \left| size(X) - size(Y) \right|`}</LatexMath></B>
                            </Box>
                            <Box title={<span>Differenza di <LatexMath>{r`q`}</LatexMath>-grammi</span>}>
                                <Aside>
                                    L&apos;edit distance è limitata superiormente dal numero di <LatexMath>{r`q`}</LatexMath>-grammi per cui i due token differiscono.
                                </Aside>
                                <Todo block={true}>
                                    <B><LatexMath block={true}>{r`E \geq \frac{\max ( size(X), size(Y) ) - size(X \cap Y) + q - 1}{q}`}</LatexMath></B>
                                </Todo>
                            </Box>
                            <Box title={<span>Posizione dei <LatexMath>{r`q`}</LatexMath>-grammi</span>}>
                                <Aside>
                                    Token i cui <LatexMath>{`q`}</LatexMath>-grammi si trovano in posizioni diverse avranno edit distance più alte.
                                </Aside>
                                <P>
                                    Richiede che venga tenuto traccia delle posizione dei <LatexMath>{`q`}</LatexMath>-grammi, e prevede che i <LatexMath>{`q`}</LatexMath>-grammi a <B>più di <LatexMath>{`k`}</LatexMath> posizioni di distanza</B> non vengano considerati uguali.
                                </P>
                            </Box>
                        </Split>
                    </Box>
                </Box>
            </Box>
            <Box title={<span>Tramite overlap dei <LatexMath>{`q`}</LatexMath>-grammi</span>}>
                <P>
                    Dato un token, si <B>ordinano</B> i token del vocabolario in base al numero di <LatexMath>{`q`}</LatexMath>-grammi in comune.
                </P>
                <Box title={"Coefficiente di Jaccard"}>
                    <P>
                        <B>Misura di overlap</B> tra due insiemi di <LatexMath>{`q`}</LatexMath>-grammi <LatexMath>{`X`}</LatexMath> e <LatexMath>{`Y`}</LatexMath>:
                    </P>
                    <B><LatexMath block={true}>{r`Jaccard = \frac{size(X \cap Y)}{size(X \cup Y)}`}</LatexMath></B>
                    <Aside>
                        <P>
                            Usando trigrammi, il <I>coefficiente di Jaccard</I> tra <Token>novembre</Token> e <Token>dicembre</Token> è:
                        </P>
                        <ul>
                            <LI>
                                <LatexMath>{`X \\cap Y =\\ `}</LatexMath>
                                <Token>emb</Token>&nbsp;
                                <Token>mbr</Token>&nbsp;
                                <Token>bre</Token>&nbsp;
                                <Token>re␣</Token>&nbsp;
                                <Token>e␣␣</Token>
                            </LI>
                            <LI>
                                <LatexMath>{`X \\cup Y =\\ `}</LatexMath>
                                <Token>␣␣n</Token>&nbsp;
                                <Token>␣no</Token>&nbsp;
                                <Token>nov</Token>&nbsp;
                                <Token>ove</Token>&nbsp;
                                <Token>vem</Token>&nbsp;
                                <Token>␣␣d</Token>&nbsp;
                                <Token>␣di</Token>&nbsp;
                                <Token>dic</Token>&nbsp;
                                <Token>ice</Token>&nbsp;
                                <Token>cem</Token>&nbsp;
                                <Token>emb</Token>&nbsp;
                                <Token>mbr</Token>&nbsp;
                                <Token>bre</Token>&nbsp;
                                <Token>re␣</Token>&nbsp;
                                <Token>e␣␣</Token>
                            </LI>
                            <LI>
                                <LatexMath>{`Jaccard = \\frac{size(X \\cap Y)}{size(X \\cup Y)} = \\frac{5}{15} = 0.33`}</LatexMath>
                            </LI>
                        </ul>
                    </Aside>
                </Box>
            </Box>
            <Box title={"Tramite algoritmi fonetici"}>
                <P>
                    Esistono motori di ricerca che usano un algoritmo per convertire i token nella loro
                    corrispondente <B>pronuncia</B> ed effettuano match sulla base di quest&apos;ultima.
                </P>
                <Aside>
                    Un metodo usato per correggere errori tipografici durante confronto di nomi propri è il <Anchor href={"https://en.wikipedia.org/wiki/Soundex"}>Soundex</Anchor>, un algoritmo che converte le parole in codici rappresentanti i loro suoni.
                </Aside>
            </Box>
            <Box title={"Proposte di correzione"}>
                <P>
                    Scoperti i token &quot;vicini&quot;, si può optare per varie soluzioni:
                </P>
                <Split>
                    <Box title={"Sostituzione"}>
                        <P>
                            <I>Sostituire</I> automaticamente il token originale con il più vicino ad esso.
                        </P>
                        <P>
                            Richiede che le possibili correzioni siano <B>ordinate</B>.
                        </P>
                        <Aside>
                            <P>
                                È quello che fa di default Google:
                            </P>
                            <Image src={"/images/year3/gestione/replacement.png"} alt={"Google ha corretto il token errato per me."} width={284} height={98}/>
                        </Aside>
                    </Box>
                    <Box title={"Visualizzazione"}>
                        <P>
                            <i>Visualizzare</i> l&apos;errore all&apos;utente, e permettergli di correggerlo rapidamente.
                        </P>
                        <P>
                            Richiede più <B>interazione</B> da parte dell&apos;utente.
                        </P>
                        <Aside>
                            <P>
                                È quello che fa Google quando non è sicuro della correzione proposta:
                            </P>
                            <Image src={"/images/year3/gestione/suggestion.png"} alt={"Google suggerisce di correggere il token errato."} width={238} height={80}/>
                        </Aside>
                    </Box>
                    <Box title={"Aggiunta"}>
                        <P>
                            <i>Aggiungere</i> automaticamente alla query i token corretti.
                        </P>
                        <P>
                            Richiede più <B>tempo di ricerca</B>, perchè nella query saranno presenti più token.
                        </P>
                    </Box>
                </Split>
            </Box>
        </Box>
        <Box title={"Correzione contestualizzata"}>
            <P>
                È possibile confrontare ogni token con il contesto dei termini circostanti per rilevare ulteriori errori.
            </P>
            <Split>
                <Box title={"Conteggio dei risultati"}>
                    <P>
                        Un metodo che prevede di <B>enumerare</B> varie alternative aventi contesti concordi e di restituire quella con il <B>maggior numero di risultati</B>.
                    </P>
                </Box>
                <Box title={"Conteggio delle ricerche"}>
                    <P>
                        Un metodo che prevede di <B>enumerare</B> varie alternative aventi contesti concordi e di restituire quella che <B>è stata ricercata più volte</B>.
                    </P>
                </Box>
            </Split>
        </Box>
        <Split title={"Indici"}>
            <Box title={"Cosa sono?"}>
                <P>
                    Gli indici sono <B>strutture dati</B> in cui vengono inseriti i documenti e i loro token dopo essere stati preparati.
                </P>
                <P>
                    L&apos;<B><I>indicizzazione</I></B> è la procedura che crea e mantiene aggiornati uno o più <B><I>indici</I></B>.
                </P>
            </Box>
            <Box title={"A cosa servono?"}>
                <P>
                    Sono fondamentali per <B>velocizzare notevolmente</B> le ricerche e per permettere certi tipi di operazioni sulle query.
                </P>
            </Box>
        </Split>
        <Box title={"Matrice di incidenza"}>
            <P>
                Un indice basato sulla costruzione di una matrice in cui le righe sono i <B>documenti</B>, le colonne i <B>token</B> e le celle valori booleani che descrivono se il token compare nel documento.
            </P>
            <P>
                È terribilmente <B>inefficiente</B> in termini di spazio, perchè la matrice è <B>sparsa</B>.
            </P>
            <P>
                Una sua evoluzione spazialmente più efficiente è l&apos;<B><I>inverted index</I></B>.
            </P>
        </Box>
        <Box title={"Inverted index"}>
            <P>
                L&apos;<B>indice</B> più comune, costituito da tante <B><I>posting list</I></B> raggiungibili attraverso un <B><I>vocabolario</I></B>.
            </P>
            <Split>
                <Box title={"Posting list"}>
                    <P>
                        L&apos;<B>insieme</B> di tutte le <B>occorrenze</B> di un dato token.
                    </P>
                    <P>
                        Può essere realizzata in due modi:
                    </P>
                    <ul>
                        <LI>
                            <U>Document-based</U>: lista ordinata di documenti con la <B>frequenza del token</B> in essi
                        </LI>
                        <LI>
                            <U>Word-based</U>: lista ordinata di documenti che punta a una lista ordinata delle <B>posizioni</B> del token in essi
                        </LI>
                    </ul>
                    <P>
                        Essendo le liste <B>ordinate</B>, vi è possibile effettuare operazioni di <B>unione</B> e <B>intersezione</B> in <B>tempo lineare</B> utilizzando dei <B>cursori</B>.
                    </P>
                    <P>
                        Non è però altrettanto efficiente in operazioni di <B>negazione</B>.
                    </P>
                </Box>
                <Box title={"Vocabolario"}>
                    <P>
                        L&apos;insieme delle <B>associazioni</B> tra <B>token</B> e la loro <B>posting list</B>.
                    </P>
                    <P>
                        Ci sono tanti modi diversi di implementarlo:
                    </P>
                    <ul>
                        <LI>
                            <U>Doppia lista ordinata</U>: <B>lista di token</B> che punta a una <B>lista di occorrenze</B>
                        </LI>
                        <LI>
                            <U>Trie</U>: <B>albero</B> in cui ogni arco rappresenta una <B>stringa</B> e ogni nodo una <B>concatenazione</B> delle stringhe tra sè e la radice
                            <ul>
                                <LI><U>Prefix tree</U>: <B>trie</B> che usa i <B>prefissi</B> dei token</LI>
                                <LI><U>Suffix tree</U>: <B>trie</B> che usa i <B>suffissi</B> dei token</LI>
                            </ul>
                        </LI>
                        <LI>
                            <U>B+ tree</U>: <B>albero</B> particolarmente ottimizzato, in cui le foglie sono le occorrenze
                        </LI>
                        <LI>
                            <U>Dizionario</U>: <B>hashmap</B> che usa come chiave il <B>token</B> stesso, e una lista di occorrenze come <B>valore</B>
                        </LI>
                    </ul>
                    <P>
                        Generalmente, occupano <B>spazio logaritmico</B> rispetto al numero di token.
                    </P>
                </Box>
            </Split>
        </Box>
        <Split title={"Query languages"}>
            <Box title={"Cosa sono?"}>
                <P>
                    Ogni motore di ricerca implementa un diverso <B><I>query language</I></B>, un&apos;<B>interfaccia</B> per l&apos;utente che gli permette di effettuare ricerche in base alla sua necessità di informazioni <I><UIN/></I>.
                </P>
                <Aside>
                    Su Google puoi scrivere la tua domanda in linguaggio naturale e ricevere una risposta, ma ci puoi anche aggiungere qualche operatore come <code>site:stackoverflow.com</code> per restringere la ricerca!
                </Aside>
                <P>
                    Ogni query language può poi implementare diverse <B>funzionalità</B> in base al tipo di documento indicizzato.
                </P>
            </Box>
            <Box title={"A cosa servono?"}>
                <P>
                    Essendo una <B>via di mezzo</B> tra linguaggio naturale e linguaggio di programmazione, permettono a un <B>utente qualunque</B> di fruire del motore di ricerca, senza bisogno di conoscenze approfondite sul suo funzionamento.
                </P>
            </Box>
        </Split>
        <Split>
            <Box title={"Keywords semplici"}>
                <P>
                    All&apos;interno della query vengono inserite <B>una o più keywords</B> da ricercare all&apos;interno dei documenti.
                </P>
                <Aside>
                    <P>
                        Praticamente tutti i motori di ricerca le supportano!
                    </P>
                    <Code language={"text"}>
                        Divina Commedia Dante
                    </Code>
                </Aside>
            </Box>
            <Box title={"Keyword consecutive"}>
                <P>
                    Prevedono la possibilità di richiedere che due o più keyword siano <B><I>consecutive</I></B>.
                </P>
                <Aside>
                    <P>
                        Solitamente è possibile specificarlo circondando di virgolette le keyword in questione.
                    </P>
                    <Code language={"python"}>
                        &quot;Nel mezzo del cammin di nostra vita&quot;
                    </Code>
                </Aside>
            </Box>
            <Box title={"Keyword distanziate"}>
                <P>
                    Prevedono la possibilità di richiedere che due o più keyword siano a una certa <B><I>distanza</I></B> una dall&apos;altra.
                </P>
                <Aside>
                    <P>
                        È molto raro al giorno d&apos;oggi che un motore di ricerca permetta di ricercare la distanza tra le keyword.
                    </P>
                    <P>
                        Uno dei pochi motori di ricerca che lo permette ancora è <Anchor href={"https://en.wikipedia.org/wiki/Westlaw"}>Westlaw</Anchor>.
                    </P>
                    <Code language={"text"}>
                        Dante /3 Beatrice
                    </Code>
                </Aside>
            </Box>
        </Split>
        <Split>
            <Box title={"Patterns"}>
                <P>
                    Prevedono la possibilità di cercare <B>prefissi</B>, <B>suffissi</B>, <B>sottostringhe</B> e <B>intervalli</B> di keyword.
                </P>
                <Aside>
                    <P>
                        Le <B><Regex/></B> e i <B><Glob/></B> sono i pattern utilizzati più di frequente.
                    </P>
                    <Code language={"regex"}>
                        /^V.?rgilio/
                    </Code>
                    <Code language={"glob"}>
                        **/V?rgilio.png
                    </Code>
                </Aside>
            </Box>
            <Box title={"Concetti"}>
                <P>
                    Prevedono la possibilità di usare tag provenienti da un <B>thesaurus limitato</B> di cui è <B>garantita</B> la precisione.
                </P>
                <Aside>
                    <P>
                        Il più famoso motore di ricerca a concetti è <Anchor href={"https://pubmed.ncbi.nlm.nih.gov/"}>PubMed</Anchor>, e i concetti ricercabili possono essere trovati su <Anchor href={"https://www.ncbi.nlm.nih.gov/mesh/"}>MeSH</Anchor>.
                    </P>
                    <Code language={"text"}>
                        &quot;Plague&quot;[Mesh]
                    </Code>
                </Aside>
            </Box>
        </Split>
        <Split>
            <Box title={"Struttura"}>
                <P>
                    Prevedono la possibilità di limitare la query a <B>specifiche sezioni</B> del documento.
                </P>
                <Aside>
                    <P>
                        Un esempio di query strutturali è <Anchor href={"https://books.google.it/advanced_book_search?hl=it"}>Google Books</Anchor>.
                    </P>
                    <Code language={"text"}>
                        inauthor:Dante inauthor:Alighieri
                    </Code>
                </Aside>
            </Box>
            <Box title={"Operatori booleani"}>
                <P>
                    Prevedono la possibilità di effettuare più query e applicare le operazioni di <B>intersezione</B>, <B>unione</B> e <B>negazione</B> sui risultati.
                </P>
                <Aside>
                    <P>
                        Moltissimi motori di ricerca permettono boolean query, inclusa la <Anchor href={"https://www.postgresql.org/docs/current/textsearch.html"}>Full Text Search di PostgreSQL</Anchor>.
                    </P>
                    <Code language={"python"}>
                        &quot;Dante&quot; and &quot;Vergil&quot; and (&quot;Devil May Cry&quot; or &quot;DMC&quot;) and not &quot;Divina Commedia&quot;
                    </Code>
                </Aside>
            </Box>
        </Split>
        <Split title={<span>Implementazione dei <I>patterns</I></span>}>
            <Box title={"Tramite prefix e suffix tree"}>
                <ol>
                    <LI>
                        Separa <B>prefisso</B> e <B>suffisso</B> in due parti collegate da un <code>AND</code>:
                        <Aside>
                            <Token>ca*e</Token> → <Token>ca*</Token> <code>AND</code> <Token>*e</Token>
                        </Aside>
                    </LI>
                    <LI>
                        Trova i risultati delle due parti attraverso un doppio vocabolario implementato con sia
                        prefix sia suffix tree:
                        <Aside>
                            <ul>
                                <LI><Token>ca*</Token> → 1:1, 1:8, 2:113, 4:231</LI>
                                <LI><Token>*e</Token> → 1:8, 1:32, 2:113, 3:12, 4:1 </LI>
                            </ul>
                        </Aside>
                    </LI>
                    <LI>
                        Effettua l&apos;<B>intersezione</B> delle due parti:
                        <Aside>
                            <Token>ca*</Token> <code>AND</code> <Token>*e</Token> → 1:8, 2:113
                        </Aside>
                    </LI>
                </ol>
                <P>
                    È costoso in termini di tempo: ci saranno tanti risultati che andranno processati, e
                    l&apos;intersezione è <LatexMath>{`O(n + m)`}</LatexMath>.
                </P>
            </Box>
            <Box title={"Tramite permuterm tree"}>
                <Box title={"Permuterm tree"}>
                    <P>
                        Un particolare <B>prefix tree</B> in cui vengono inserite tutte le possibili permutazioni di ogni token, con in aggiunta un marcatore per la fine della parola (░):
                    </P>
                    <Aside>
                        <Token>ciao</Token> → <Token>ciao░</Token> <Token>iao░c</Token> <Token>ao░ci</Token> <Token>iao░c</Token>
                    </Aside>
                </Box>
                <P>
                    È possibile effettuare ricerche wildcard <B>ruotando la wildcard a destra</B>, trasformando
                    tutti i pattern in <B>prefissi</B>:
                </P>
                <Aside>
                    <ul>
                        <LI>
                            Ricerca semplice:
                            <Aside>
                                <Token>ciao</Token> → <Token>ciao░</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Ricerca di prefisso:
                            <Aside>
                                <Token>ci*</Token> → <Token>░ci*</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Ricerca di suffisso:
                            <Aside>
                                <Token>*ao</Token> → <Token>ao░*</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Ricerca di sottostringa:
                            <Aside>
                                <Token>*ia*</Token> → <Token>ia*</Token>
                            </Aside>
                        </LI>
                        <LI>
                            Ricerca di intervallo:
                            <Aside>
                                <Token>c*o</Token> → <Token>o░c*</Token>
                            </Aside>
                        </LI>
                    </ul>
                </Aside>
                <P>
                    È costoso in termini di spazio: ogni termine va salvato molte volte nel vocabolario (<I>permuterm problem</I>).
                </P>
                <Aside>
                    In inglese, in cui i token sono lunghi in media <LatexMath>4</LatexMath>, questo porta a una quadruplicazione <LatexMath>{r`\times 4`}</LatexMath> dello spazio usato.
                </Aside>
            </Box>
            <Box title={<span>Tramite <LatexMath>{`q`}</LatexMath>-gram indexes</span>}>
                <Box title={<span><LatexMath>{`q`}</LatexMath>-gram index</span>}>
                    <P>
                        <B>Vocabolario aggiuntivo</B> che associa <LatexMath>{`q`}</LatexMath>-grammi ai token corrispondenti del vocabolario principale.
                    </P>
                    <Aside>
                        <Token>␣ci</Token> → <Token>ciao</Token> <Token>cibo</Token> <Token>cinefilo</Token>
                    </Aside>
                </Box>
                <P>
                    È possibile interpretare la ricerca come <B>intersezione di <LatexMath>{`q`}</LatexMath>-grammi</B>:
                </P>
                <Aside>
                    <P>
                        Utilizzando dei bigrammi:
                    </P>
                    <Aside>
                        <Token>lun*</Token> → <Token>␣l</Token> <code>AND</code> <Token>lu</Token> <code>AND</code> <Token>un</Token>
                    </Aside>
                </Aside>
                <P>
                    I risultati della ricerca andranno <B>post-filtrati</B>, in quanto ci potrebbero essere dei <B>falsi positivi</B>:
                </P>
                <Aside>
                    <P>
                        Utilizzando dei bigrammi:
                    </P>
                    <Aside>
                        <Token>mon*</Token> → <Token>␣m</Token> <code>AND</code> <Token>mo</Token> <code>AND</code> <Token>on</Token> → <Token stopword={true}>moon</Token> <Token>monday</Token>
                    </Aside>
                </Aside>
                <Aside>
                    <P>
                        È un&apos;ottima via di mezzo tra prefix-suffix tree e permuterm tree sia per il tempo impiegato sia per lo spazio richiesto.
                    </P>
                </Aside>
            </Box>
        </Split>
        <Split title={<span>Modelli di <IR/></span>}>
            <Box title={"Cosa sono?"}>
                <P>
                    Sono <B>modelli matematici</B> in grado di <B>selezionare</B> e <B>ordinare</B> i documenti in base alla loro <B>rilevanza</B> rispetto alla query.
                </P>
            </Box>
            <Box title={"A cosa servono?"}>
                <P>
                    Stabiliscono i <B>risultati richiamati</B> dal motore di ricerca e l&apos;<B>ordine con cui vengono visualizzati</B>.
                </P>
            </Box>
        </Split>
        <Box title={"Modelli classici"}>
            <P>
                Rappresentano la query come un <B>insieme di index term</B>, e assegnano le rilevanze confrontando l&apos;insieme con gli index term dei documenti.
            </P>
            <Aside>
                Sono usati solitamente dai motori di ricerca web.
            </Aside>
            <P>
                Ad ogni index term del documento viene <B>indipendentemente</B> assegnato un <B><I>peso</I></B> in base alla sua rilevanza nella query.
            </P>
        </Box>
        <Split>
            <Box title={"Modello booleano"}>
                <P>
                    <B>Modello classico</B> che rappresenta la query come un <B><Predicato/> <I>booleano</I></B>, e genera la rilevanza valutandolo su ogni documento:
                </P>
                <ul>
                    <LI><B><code>1</code></B> se il <Predicato/> è <B>vero</B></LI>
                    <LI><B><code>0</code></B> se il <Predicato/> è <B>falso</B></LI>
                </ul>
            </Box>
            <Box title={"Modello fuzzy"}>
                <P>
                    Variante del <B>modello booleano</B> che permette ai documenti di <B>soddisfare
                                                                                            parzialmente</B> il <Predicato/>:
                </P>
                <ul>
                    <LI><B><code>1.00</code></B> se il <Predicato/> è <B>vero</B></LI>
                    <LI><B><code>0.XX</code></B> se il <Predicato/> è <B>parzialmente vero</B></LI>
                    <LI><B><code>0.00</code></B> se il <Predicato/> è <B>falso</B></LI>
                </ul>
                <P>
                    Le <B>operazioni fuzzy</B> diventano quindi:
                </P>
                <ul>
                    <LI><U><code>AND</code></U>: <B><LatexMath>{`min( x_{A},\\ x_{B} )`}</LatexMath></B></LI>
                    <LI><U><code>OR</code></U>: <B><LatexMath>{`max( x_{A},\\ x_{B} )`}</LatexMath></B></LI>
                    <LI><U><code>NOT</code></U>: <B><LatexMath>{`1 - x_{A}`}</LatexMath></B></LI>
                </ul>
            </Box>
        </Split>
        <Split>
            <Box title={"Modello vettoriale"}>
                <P>
                    Modello classico che rappresenta il vocabolario come uno <B>spazio vettoriale</B>, in cui ogni dimensione rappresenta un token.
                </P>
                <P>
                    Ogni documento viene rappresentato come un <B>vettore <LatexMath>{`d`}</LatexMath></B>, i cui valori sono <B>pesi <LatexMath>{`d_i`}</LatexMath></B> assegnati in base a quanto il token è signficativo all&apos;interno del documento.
                </P>
                <Aside>
                    Il metodo più comunemente usato per assegnare i pesi è il <TFIDF/>, descritto successivamente.
                </Aside>
                <Aside>
                    La matrice della collezione <LatexMath>{`\\mathbf{D}`}</LatexMath> è estremamente sparsa: viene implementata <B>per colonne</B> attraverso un <B>inverted index</B>.
                </Aside>
                <P>
                    Le query vengono anch&apos;esse trasformate in <B>vettori <LatexMath>{`q`}</LatexMath></B>, e le rilevanze vengono ottenute dalla <B>similitudine vettoriale</B> tra i vettore query e i vettori documenti.
                </P>
                <Split>
                    <Box title={<span>Peso <TFIDF/></span>}>
                        <P>
                            Un metodo di assegnamento peso che si basa sul <B>prodotto</B> dei fattori <B><TF/></B> e <B><IDF/></B>:
                        </P>
                        <B><LatexMath block={true}>{`d_i = tf_{norm}(i) \\cdot idf_{log}(i)`}</LatexMath></B>
                        <Box title={<span><TF/>: Term frequency</span>}>
                            <P>
                                Misura quanto un token è <B>frequente</B> nel <B>singolo documento</B>:
                            </P>
                            <B><LatexMath
                                block={true}
                            >{`tf(i) = \\frac{occorrenze}{totale\\ token}`}</LatexMath></B>
                            <P>
                                Nella formula principale, viene <B>normalizzato</B> dividendolo per il <TF/> più alto del documento, limitandolo così a valori tra 0 e 1:
                            </P>
                            <B><LatexMath
                                block={true}
                            >{`tf_{norm}(i) = \\frac{tf(i)}{\\max_{j:\\ docs}\\ tf(j)}`}</LatexMath></B>
                        </Box>
                        <Box title={<span><IDF/>: Inverse document freq.</span>}>
                            <P>
                                Misura quanto un token è <B>raro</B> nella <B>collezione di documenti</B>:
                            </P>
                            <B><LatexMath
                                block={true}
                            >{`idf(i) = \\frac{totale\\ documenti}{documenti\\ con\\ occ.}`}</LatexMath></B>
                            <P>
                                Nella formula principale, viene <B>logaritmizzato</B>, al fine di ridurre significativamente il suo impatto:
                            </P>
                            <B><LatexMath block={true}>{`idf_{log}(i) = \\log(idf(i))`}</LatexMath></B>
                        </Box>
                    </Box>
                    <Box title={"Similitudine vettoriale"}>
                        <P>
                            Un modo di misurare la similitudine tra <B>insiemi di token</B> rappresentati come <B>dimensioni vettoriali</B>.
                        </P>
                        <Box title={"Coseno di similitudine"}>
                            <P>
                                Si basa sulla <B>norma a 2</B>, e corrisponde a cercare l&apos;angolo centrato all&apos;origine tra i due vettori:
                            </P>
                            <B><LatexMath block={true}>{`
                                sim_{\\cos} (d, q) = 
                                \\frac{
                                    \\vec{d} \\cdot \\vec{q}
                                }{
                                    \\| \\vec{d} \\|_2 \\cdot \\| \\vec{q} \\|_2
                                } =
                                \\frac{
                                    \\sum_{i = 0}^{dim.} (d_i \\cdot q_i )
                                }{
                                    \\sqrt{\\sum_{i = 0}^{dim.} (d_i^2)} \\cdot \\sqrt{\\sum_{i = 0}^{dim.} (q_i^2})
                                }
                            `}</LatexMath></B>
                            <Aside>
                                Solitamente viene usata nei modelli di <IR/> vettoriali, descritti in seguito.
                            </Aside>
                        </Box>
                        <Aside>
                            <P>
                                Altre misure comuni di similitudine vettoriale sono:
                            </P>
                            <ul>
                                <LI>La <Anchor href={"https://it.wikipedia.org/wiki/Distanza_euclidea"}>distanza euclidea</Anchor></LI>
                                <LI>Il <Anchor href={"https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient"}>Sørensen–Dice coefficient</Anchor></LI>
                                <LI>Il <Anchor href={"https://en.wikipedia.org/wiki/Jaccard_index"}>Jaccard Index</Anchor></LI>
                                <LI>La <Anchor href={"https://it.wikipedia.org/wiki/Distanza_di_Minkowski"}>distanza di Minkowski</Anchor></LI>
                            </ul>
                        </Aside>
                    </Box>
                </Split>
                <Box title={"Modello probabilistico"}>
                    <P>
                        Implementazione del modello vettoriale che ordina i documenti <LatexMath>{`d`}</LatexMath> in base alla <B>probabilità <LatexMath>{`R`}</LatexMath></B> che siano <B>rilevanti</B> per la query <LatexMath>{`q`}</LatexMath>:
                    </P>
                    <B><LatexMath block={true}>{`sim_{prob} = \\frac{P(R\\ |\\ d, q)}{P(\\overline{R}\\ |\\ d, q)}`}</LatexMath></B>
                    <P>
                        Si dimostra che è possibile determinare quanto la presenza di un dato token <LatexMath>{`k_i`}</LatexMath> in un documento <LatexMath>{r`d`}</LatexMath> ne <B>contribuisca alla rilevanza</B> per la query <LatexMath>{r`\vec{q}`}</LatexMath>:
                    </P>
                    <B><LatexMath block={true}>{`
                        c_i = 
                        \\log \\frac{P(k_i\\ |\\ R, \\vec{q})}{1 - P(k_i\\ |\\ R, \\vec{q})}
                        +
                        \\log \\frac{1 - P(k_i\\ |\\ \\overline{R}, \\vec{q})}{P(k_i\\ |\\ \\overline{R}, \\vec{q})}
                    `}</LatexMath></B>
                    <Split>
                        <Aside builtinColor="lime">
                            <B><LatexMath block={true}>{`
                                \\log \\frac{P(k_i\\ |\\ R, \\vec{q})}{1 - P(k_i\\ |\\ R, \\vec{q})}
                            `}</LatexMath></B>
                            <P>
                                Il valore del primo &quot;blocco&quot; dipende dalla presenza del token <LatexMath>{`k_i`}</LatexMath> nei documenti <B>rilevanti</B>: più il token vi appare, più il valore sarà <B>alto</B>.
                            </P>
                        </Aside>
                        <Aside builtinColor="red">
                            <B><LatexMath block={true}>{`
                                \\log \\frac{1 - P(k_i\\ |\\ \\overline{R}, \\vec{q})}{P(k_i\\ |\\ \\overline{R}, \\vec{q})}
                            `}</LatexMath></B>
                            <P>
                                Il valore del primo &quot;blocco&quot; dipende dalla presenza del token <LatexMath>{`k_i`}</LatexMath> nei documenti <B>non rilevanti</B>: più il token vi appare, più il valore sarà <B>basso</B>.
                            </P>
                        </Aside>
                    </Split>
                    <Aside>
                        In generale, <LatexMath>{`c_i`}</LatexMath> avrà un valore <Color builtin={"lime"}>positivo</Color> se è più probabile che il termine appaia in documenti rilevanti e non in quelli irrilevanti; in caso contrario, esso avrà valore <Color builtin={"red"}>negativo</Color>.
                    </Aside>
                </Box>
            </Box>
        </Split>
        <Box title={"Modello Okapi BM25"}>
            <P>
                Modello classico che ordina i documenti in base a un <B>punteggio <RSV/></B> ad essi assegnato.
            </P>
            <P>
                L&apos;<RSV/> deriva dalla somma per ogni termine della query del prodotto di tre fattori:
            </P>
            <B><LatexMath block={true}>{`RSV = \sum_{t \in q} (x \\cdot y \\cdot z)`}</LatexMath></B>
            <Split>
                <Box title={<span>Fattore <LatexMath>{`x`}</LatexMath></span>}>
                    <P>
                        Un moltiplicatore basato sull&apos;<B><IDF/></B> dei termini della query presenti nel documento:
                    </P>
                    <B><LatexMath block={true}>{r`
                        x = ( idf_{\log} )
                    `}</LatexMath></B>
                </Box>
                <Box title={<span>Fattore <LatexMath>{`y`}</LatexMath></span>}>
                    <P>
                        Un moltiplicatore basato sulla <B><TF/> nel documento</B> dei termini nella query:
                    </P>
                    <B><LatexMath block={true}>{r`
                        y' = \frac{ (k_1 + 1) \cdot tf_{td} }{ k_1 + tf_{td} }
                    `}</LatexMath></B>
                    <Aside>
                        <LatexMath>{r`k_1`}</LatexMath> regola la <B>priorità data al fattore</B>: se <LatexMath>0</LatexMath> la <TF/> viene ignorata e il modello diventa binario, se molto elevata invece il fattore <LatexMath>{r`b`}</LatexMath> monopolizza gli altri.
                    </Aside>
                    <P>
                        Ad esso viene in genere applicata una normalizzazione basata sulla <B>lunghezza del documento</B>:
                    </P>
                    <B><LatexMath block={true}>{r`
                        y = \frac{(k_1 + 1) \cdot tf_{td}}{k_1 \cdot \left( 1 - b + \left( b \cdot \frac{L_d}{L_{avg}} \right) \right) + tf_{td}}
                    `}</LatexMath></B>
                    <Aside>
                        <LatexMath>{r`b`}</LatexMath> regola <B>quanto viene applicata la normalizzazione</B>: se <LatexMath>0</LatexMath>, essa viene disattivata, mentre se <LatexMath>1</LatexMath> viene applicata completamente.
                    </Aside>
                </Box>
                <Box title={<span>Fattore <LatexMath>{`z`}</LatexMath></span>}>
                    <P>
                        Un moltiplicatore basato sulla <B><TF/> nella query stessa</B> dei termini nella query:
                    </P>
                    <B><LatexMath
                        block={true}
                    >{`z = \\frac{(k_3 + 1) \\cdot tf_{tq}}{k_3 + tf_{tq}}`}</LatexMath></B>
                    <Aside>
                        <LatexMath>{r`k_3`}</LatexMath> regola la <B>priorità data ai vari token</B> in base alla loro <TF/> nella query stessa: se <LatexMath>0</LatexMath>, questa funzionalità viene disattivata, mentre se
                    </Aside>
                    <P>
                        Ad esso non viene ovviamente applicata alcuna normalizzazione.
                    </P>
                </Box>
            </Split>
        </Box>
        <Box title={"Link Analysis Model"}>
            <P>
                Modello per classificare documenti intercollegati in base a <B>come essi sono collegati</B> tra loro.
            </P>
            <Aside>
                Una pagina non è importante in base a quanto dice di esserlo, ma in base a quanto le altre pagine dicono che lo è.
            </Aside>
            <Split>
                <Box title={"PageRank"}>
                    <P>
                        Algoritmo di <I>Link Analysis Ranking</I> <B>query-independent</B> che assegna un <B>grado</B> a ogni pagina indicizzata.
                    </P>
                    <Aside>
                        È il primo algoritmo utilizzato da Google.
                    </Aside>
                    <Box title={"Rank"}>
                        <P>
                            Misura <B>iterativa</B> di quanto una pagina è importante rispetto a tutte le altre indicizzate.
                        </P>
                        <B><LatexMath block={true}>{r`
                            R'_i(p) = (1 - \alpha) \cdot \sum_{q:\ parents} \left( \frac{R_{i-1}(q)}{N_q} \right) + \alpha \cdot E(p)
                        `}</LatexMath></B>
                        <P>
                            In cui:
                        </P>
                        <ul>
                            <LI>
                                <B><LatexMath>{`q`}</LatexMath></B> è una pagina che <B>referenzia</B> quella in questione;
                            </LI>
                            <LI>
                                <B><LatexMath>{`R_{i-1}(q)`}</LatexMath></B> è il <B>rank normalizzato</B> della pagina <LatexMath>{r`q`}</LatexMath>;
                            </LI>
                            <LI>
                                <B><LatexMath>{`N_q`}</LatexMath></B> è il numero <B>totale di link</B> presenti nella pagina <LatexMath>q</LatexMath>;
                            </LI>
                            <LI>
                                <B><LatexMath>{`E(p)`}</LatexMath></B> è una <B><I>sorgente di rank</I></B>;
                            </LI>
                            <LI>
                                <B><LatexMath>{`\\alpha`}</LatexMath></B> è un parametro che regola l&apos;<B>emissione della sorgente</B> di rank e la <B>dissipazione</B> del rank preesistente.
                            </LI>
                        </ul>
                        <Aside>
                            Converge molto in fretta: <LatexMath>{`O(log\\ n)`}</LatexMath>!
                        </Aside>
                        <Box title={"Sorgenti di rank"}>
                            <P>
                                Funzione che introduce nuovo rank nel sistema ad ogni iterazione.
                            </P>
                            <Aside>
                                Se non venisse introdotto nuovo rank nel sistema, si formerebbero lentamente dei <B>pozzi</B> in presenza di cicli o pagine senza nessun collegamento uscente.
                            </Aside>
                            <P>
                                PageRank normale prevede che questa funzione sia costante; è possibile però <B>personalizzarlo</B> rendendo la funzione variabile, facendo in modo che vengano assegnati rank più alti a certi tipi di pagine.
                            </P>
                            <Aside>
                                Ad esempio, per prioritizzare le homepage rispetto alle sottopagine è possibile fare che:
                                <LatexMath block={true}>{r`
                                    E(p) = \begin{cases}
                                        1 \qquad pagina\ principale\\
                                        0 \qquad sottopagine
                                    \end{cases}
                                `}</LatexMath>
                            </Aside>
                        </Box>
                    </Box>
                    <Box title={"Rank normalizzato"}>
                        <P>
                            <B>Rank</B> riscalato a valori inclusi <B>tra 0 e 1</B>.
                        </P>
                        <B><LatexMath block={true}>{r`
                            R_i(p) = \frac{R'_i(p)}{\sum_{d:\ pages} \left( R'_i(d) \right)}
                        `}</LatexMath></B>
                        <P>
                            Solitamente, il rank viene rinormalizzato ad ogni iterazione.
                        </P>
                    </Box>
                </Box>
                <Box title={"HITS"}>
                    <P>
                        Algoritmo di <I>Link Analysis Ranking</I> <B>query-dependent</B> che attribuisce <B>due diversi valori</B> ad ogni pagina: <B><I>autorità</I></B> e <B><I>hubness</I></B>.
                    </P>
                    <Aside>
                        Viene utilizzato per determinare l&apos;importanza delle <B>riviste scientifiche</B>.
                    </Aside>
                    <P>
                        Viene applicato solo a un <I>base set</I>, ovvero all&apos;unione del <I>root set</I> (i match
                        della query) con tutti i nodi ad essi <B>direttamente connessi</B>.
                    </P>
                    <Split>
                        <Box title={"Autorità"}>
                            <P>
                                Misura di quanto la pagina in questione <B>viene referenziata</B> da altri siti
                                autoritativi.
                            </P>
                            <Aside>
                                Quanto una pagina riceve collegamenti &quot;importanti&quot; in entrata.
                            </Aside>
                            <B><LatexMath block={true}>{r`
                                a'_i(p) = \sum_{e:\ entering} h_{i-1}(e)
                            `}</LatexMath></B>
                        </Box>
                        <Box title={"Hubness"}>
                            <P>
                                Misura di quanto la pagina in questione <B>referenzia siti</B> autoritativi.
                            </P>
                            <Aside>
                                Quanto una pagina ha collegamenti &quot;importanti&quot; in uscita.
                            </Aside>
                            <B><LatexMath block={true}>{r`
                                h'_i(p) = \sum_{l:\ leaving} a_{i-1}(l)
                            `}</LatexMath></B>
                        </Box>
                    </Split>
                    <Split>
                        <Box title={"Autorità normalizzata"}>
                            <P>
                                <B>Autorità</B> riscalata a valori inclusi <B>tra 0 e 1</B>.
                            </P>
                            <Todo block={true}><B><LatexMath block={true}>{r`
                                a_i(p) = \frac{a'_i(p)}{\sum_{d:\ pages} \left( a'_i(d) \right)}
                            `}</LatexMath></B></Todo>
                        </Box>
                        <Box title={"Hubness normalizzata"}>
                            <P>
                                <B>Hubness</B> riscalata a valori inclusi <B>tra 0 e 1</B>.
                            </P>
                            <Todo block={true}><B><LatexMath block={true}>{r`
                                h_i(p) = \frac{h'_i(p)}{\sum_{d:\ pages} \left( h'_i(d) \right)}
                            `}</LatexMath></B></Todo>
                        </Box>
                    </Split>
                    <Aside>
                        Purtroppo, è facile da manipolare, quindi non si applica molto bene ad ambienti non-regolati come l&apos;intero web.
                    </Aside>
                </Box>
            </Split>
        </Box>
        <Split title={<span>Profilazione sistemi <IR/></span>}>
            <Box title={"Cos'è?"}>
                <P>
                    <B>Misurazioni</B> che vengono effettuate sui sistemi di <IR/>.
                </P>
                <Aside>
                    Solitamente trattano la <B>velocità di indicizzazione</B>, la <B>velocità di ricerca</B>, l&apos;efficacia del <B>query language</B>, l&apos;<B>user interface</B>, il <B>prezzo</B>...
                </Aside>
            </Box>
            <Box title={"A cosa serve?"}>
                <P>
                    Per vedere <B>quanto funziona bene</B> un sistema di <IR/>!
                </P>
                <Aside>
                    Solitamente, la misura più importante è la <B>soddisfazione dell&apos;utente</B>, che generalmente coincide con la <B>rilevanza dei risultati di ricerca</B>.
                </Aside>
            </Box>
        </Split>
        <Box title={"Benchmark"}>
            <P>
                Per ottenere delle misure, solitamente si preparano in anticipo delle <B>query</B> dette <I>benchmark</I> delle quali si è <B>già a conoscenza dei documenti rilevanti</B>.
            </P>
            <Aside>
                I documenti rilevanti possono essere selezionati a mano, o ricavati dai dati di utilizzo degli utenti (link cliccati o ignorati).
            </Aside>
        </Box>
        <Box title={"Misure comuni"}>
            <P>
                Le due misure usate più di frequente per misurare l&apos;utilità dei risultati sono <B><I>recall</I></B> e <B><I>precision</I></B>.
            </P>
            <Split>
                <Box title={"Recall"}>
                    <P>
                        Misura <B>quanti documenti rilevanti sono stati <I>richiamati</I></B> dalla collezione:
                    </P>
                    <B><LatexMath block={true}>{`Recall = \\frac{size(A \\cap R)}{size(R)}`}</LatexMath></B>
                </Box>
                <Box title={"Precision"}>
                    <P>
                        Misura <B>quanti documenti richiamati sono rilevanti</B>:
                    </P>
                    <B><LatexMath block={true}>{`Precision = \\frac{size(A \\cap R)}{size(A)}`}</LatexMath></B>
                </Box>
            </Split>
            <Aside>
                Generalmente, recall e precision sono <B>inversamente proporzionali</B>!
            </Aside>
        </Box>
        <Box title={"Misure derivate"}>
            <Split>
                <Box title={"R-Precision"}>
                    <P>
                        La <B>precisione</B> di una query che richiama <LatexMath>{`R`}</LatexMath> elementi.
                    </P>
                </Box>
                <Box title={"R-Recall"}>
                    <P>
                        A precisione <LatexMath>{`R`}</LatexMath>, il <B>richiamo</B> relativo ad una query.
                    </P>
                </Box>
            </Split>
            <Split>
                <Box title={"Curva di richiamo"}>
                    <P>
                        Curva che associa <B>percentili di richiamo</B> ai corrispondenti valori di <B>R-Precision</B>.
                    </P>
                    <Aside>
                        <P>
                            Ad esempio:
                        </P>
                        <Aside>
                            <table>
                                <thead>
                                    <tr>
                                        <th>Richiamo</th>
                                        <th>R-Precision</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    <tr>
                                        <td>10%</td>
                                        <td>90%</td>
                                    </tr>
                                    <tr>
                                        <td>20%</td>
                                        <td>60%</td>
                                    </tr>
                                    <tr>
                                        <td>30%</td>
                                        <td>10%</td>
                                    </tr>
                                    <tr>
                                        <td>...</td>
                                        <td>...</td>
                                    </tr>
                                    <tr>
                                        <td>100%</td>
                                        <td>2%</td>
                                    </tr>
                                </tbody>
                            </table>
                        </Aside>
                    </Aside>
                    <P>
                        È detta <I>naturale</I> se include un punto <B>per ogni documento richiamato</B>.
                    </P>
                    <P>
                        È detta <I>standard</I> se usa le <B>percentuali da 10% a 100%</B> come punti.
                    </P>
                </Box>
                <Box title={"Curva di richiamo interpolata"}>
                    <P>
                        Mostra il <B>valore massimo di precisione</B> per valori di richiamo <B>maggiori o uguali</B> a quelli del punto.
                    </P>
                    <Aside>
                        <P>
                            Ad esempio:
                        </P>
                        <Aside>
                            <table>
                                <thead>
                                    <tr>
                                        <th>Richiamo</th>
                                        <th>Precisione</th>
                                        <th>Interpolata</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    <tr>
                                        <td>10%</td>
                                        <td>90%</td>
                                        <td>90%</td>
                                    </tr>
                                    <tr>
                                        <td>20%</td>
                                        <td>40%</td>
                                        <td><B>50%</B></td>
                                    </tr>
                                    <tr>
                                        <td>30%</td>
                                        <td>30%</td>
                                        <td><B>50%</B></td>
                                    </tr>
                                    <tr>
                                        <td>40%</td>
                                        <td>50%</td>
                                        <td>50%</td>
                                    </tr>
                                    <tr>
                                        <td>...</td>
                                        <td>...</td>
                                        <td>...</td>
                                    </tr>
                                    <tr>
                                        <td>100%</td>
                                        <td>2%</td>
                                        <td>2%</td>
                                    </tr>
                                </tbody>
                            </table>
                        </Aside>
                    </Aside>
                    <Aside>
                        È sempre una curva <B>monotona decrescente</B>.
                    </Aside>
                </Box>
            </Split>
        </Box>
        <Box title={"Misure medie"}>
            <P>
                Esistono misure che riassumono i risultati di più benchmark in una sola.
            </P>
            <Split>
                <Box title={"Curva di precisione media"}>
                    <P>
                        Se si hanno più benchmark, corrispondenti a <B>più curve di richiamo</B>, si possono
                        ottenere le <B>medie</B> dei valori ai vari livelli, ottenendo così una <B><I>curva di
                                                                                                        precisione media</I></B>.
                    </P>
                </Box>
                <Box title={"Mean average precision"}>
                    <P>
                        La <B>media</B> di tutti i livelli di <B>precisione media</B>.
                    </P>
                </Box>
            </Split>
            <Split>
                <Box title={"Media armonica"}>
                    <P>
                        Misura che combina <B>richiamo</B> e <B>precisione</B> in un singolo valore:
                    </P>
                    <B><LatexMath block={true}>{r`
                        F = \frac{2}{\frac{1}{Recall} + \frac{1}{Precision}} = 2 \cdot \frac{Recall \cdot Precision}{Recall + Precision}
                    `}</LatexMath></B>
                </Box>
                <Box title={"Misura E"}>
                    <P>
                        Complemento della <B>media armonica</B> configurabile che permette di selezionare se
                        dare <B>priorità <LatexMath>{`b`}</LatexMath></B> alla precisione
                        (<LatexMath>{`b > 1`}</LatexMath>) oppure al richiamo (<LatexMath>{`b < 1`}</LatexMath>):
                    </P>
                    <B><LatexMath block={true}>{r`
                        E = 1 - \frac{1 + b^2}{\frac{b^2}{Recall} + \frac{1}{Precision}}
                    `}</LatexMath></B>
                </Box>
            </Split>
            <Aside>
                Attenzione: non è sufficiente confrontare le misure medie per determinare l&apos;efficacia di un motore
                di ricerca, perchè esse potrebbero <B>nascondere problemi</B> di <B>tipi specifici di query</B>!
            </Aside>
            <Split>
                <Box title={"Discounted Cumulative Gain"}>
                    <P>
                        Misura che attribuisce <B><I>guadagni</I> decrescenti</B> in base alla precisione di ogni
                        documento richiamato.
                    </P>
                    <Aside>
                        <P>
                            Una formula per il DCG potrebbe essere:
                        </P>
                        <LatexMath
                            block={true}
                        >{r`DCG = \sum_{Docs} \left( Stars \cdot 2^{- Position} \right)`}</LatexMath>
                        <P>
                            Applicata, sarebbe:
                        </P>
                        <Aside>
                            <table>
                                <thead>
                                    <tr>
                                        <th>Posizione</th>
                                        <th>Stelle</th>
                                        <th>Punti</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    <tr>
                                        <td>0</td>
                                        <td>★★★★☆</td>
                                        <td><LatexMath>{r`4 \cdot 2^{0} =\ `}</LatexMath><Color
                                            builtin={"lime"}
                                        ><LatexMath>{`+4.00`}</LatexMath></Color></td>
                                    </tr>
                                    <tr>
                                        <td>1</td>
                                        <td>★★☆☆☆</td>
                                        <td><LatexMath>{r`2 \cdot 2^{-1} =\ `}</LatexMath><Color
                                            builtin={"lime"}
                                        ><LatexMath>{`+1.00`}</LatexMath></Color></td>
                                    </tr>
                                    <tr>
                                        <td>2</td>
                                        <td>★★★☆☆</td>
                                        <td><LatexMath>{r`3 \cdot 2^{-2} =\ `}</LatexMath><Color
                                            builtin={"lime"}
                                        ><LatexMath>{`+0.75`}</LatexMath></Color></td>
                                    </tr>
                                    <tr>
                                        <td>3</td>
                                        <td>★★★★★</td>
                                        <td><LatexMath>{r`5 \cdot 2^{-3} =\ `}</LatexMath><Color
                                            builtin={"lime"}
                                        ><LatexMath>{`+0.63`}</LatexMath></Color></td>
                                    </tr>
                                    <tr>
                                        <td><B>Tot</B></td>
                                        <td><B>-----</B></td>
                                        <td><B><LatexMath>{r`4 + 1 + 0.75 + 0.63 =\ `}</LatexMath><Color
                                            builtin={"lime"}
                                        ><LatexMath>{`+6.38`}</LatexMath></Color></B></td>
                                    </tr>
                                </tbody>
                            </table>
                        </Aside>
                    </Aside>
                </Box>
                <Box title={"Normalized DCG"}>
                    <P>
                        Variante del <B>Discounted Cumulative Gain</B> che <B>divide</B> il punteggio finale per il
                        valore <B>perfetto</B> ottenibile.
                    </P>
                    <Aside>
                        <P>
                            Normalizzando la formula precedente si ottiene:
                        </P>
                        <LatexMath
                            block={true}
                        >{r`NDCG = \frac{\sum_{Docs} \left( Stars \cdot 2^{- Position} \right)}{\sum_{Docs} \left( 5 \cdot 2^{- Position} \right)}`}</LatexMath>
                    </Aside>
                </Box>
            </Split>
        </Box>
        <Split title={"Presentazione"}>
            <Box title={"Cos'è?"}>
                <P>
                    Il modo in cui i <B>risultati</B> vengono visualizzati all&apos;utente.
                </P>
            </Box>
            <Box title={"A cosa serve?"}>
                <P>
                    Permettere all&apos;utente di <B>vedere velocemente</B> tutti i risultati e di <B>scegliere</B> il
                    risultato a lui più utile.
                </P>
            </Box>
        </Split>
        <Box title={"Elenco di collegamenti"}>
            <P>
                Il motore di ricerca web mostra all&apos;utente un <B><I>elenco di collegamenti</I></B> ai documenti
                richiamati.
            </P>
            <P>
                Solitamente include alcuni dati del documento, come <B>titolo</B>, <B>sommario</B> e <B>url</B>.
            </P>
            <Box title={"Sommario"}>
                <P>
                    Un breve <B>riassunto del contenuto</B> del documento richiamato.
                </P>
                <Split>
                    <Box title={"Sommario statico"}>
                        <P>
                            Un sommario i cui contenuti dipendono solo dal <B>documento</B>, e non dalla query
                            immessa.
                        </P>
                        <Aside>
                            Sono sommari statici quelli ottenuti dai <B><code>manifest.json</code></B>, dai
                            tag <B>OpenGraph</B>, dalle <B>prime righe</B> del documento e quelli che Google genera
                            dalle <B>applicazioni web</B> (Web 3.0).
                        </Aside>
                    </Box>
                    <Box title={"Sommario dinamico"}>
                        <P>
                            Un sommario che <B>varia da query a query</B>, evidenziando le parti rilevanti del
                            documento.
                        </P>
                        <Aside>
                            Sono sommari dinamici quelli che Google genera dalle <B>pagine web statiche</B> (Web
                            1.0) e <B>dinamiche</B> (Web 2.0).
                        </Aside>
                    </Box>
                </Split>
            </Box>
        </Box>
    </>
}

export default Page
