Nottolino quantistico

Da Wikipedia, l'enciclopedia libera.

Nel 2001, Heiner Linke, fisico tedesco dell'Università di Lund, è riuscito a realizzare un nottolino quantistico, vale a dire un esperimento scientifico in grado di estrarre una corrente di elettroni a partire da un potenziale medio nullo. Questo risultato, a prima vista paradossale, può essere spiegato con semplici regole di matematica. Vediamo prima alcuni concetti necessari a comprendere come sono possibili meccanismi di questo tipo.

Nottolini termici[modifica | modifica sorgente]

Schema di un nottolino browniano
Exquisite-kfind.png Per approfondire, vedi Nottolino browniano.

I nottolini browniani, o termici, hanno una lunga storia in fisica. In una conferenza, il Premio Nobel per la fisica Richard P. Feynman si occupò di descrivere il funzionamento teorico di un nottolino browniano, e di spiegare l'impossibilità di generare, con tale meccanismo, un moto perpetuo.

Il nottolino di Feynman consiste in una ruota dentata, una molla, un dente d'arresto, un asse munito di pale. L'asse si collega alla ruota dentata, la quale viene tenuta in posizione dal dente e dalla molla. I denti della ruota sono arcuati, in maniera da consentire la rotazione in un solo verso, opponendo resistenza al moto nel verso opposto incastrandosi nel dente, spinto verso il basso dalla molla. Il tutto è immerso in un gas.

L'agitazione termica delle molecole di gas le fa urtare contro le pale. Gli urti nel verso corretto, se sufficientemente potenti, fanno compiere lo scatto di un dente al meccanismo. Gli urti nel verso opposto, invece, sono inefficaci a produrre un movimento, perché vengono sempre ostacolati dal dente di arresto. Tuttavia, questo contrasto genera calore, e ben presto il sistema formato dalla molla e dal dente diventa così caldo da non poter più ostacolare nulla: la ruota resta alla mercé del moto browniano.

Non è dunque possibile utilizzare una tale macchina per il moto perpetuo, in accordo con il secondo principio della termodinamica.

Nottolini browniani funzionanti[modifica | modifica sorgente]

Tuttavia, esiste un metodo per riuscire a ricavare un lavoro dall'agitazione termica, a patto di accettare, qualche volta, di compiere un lavoro opposto, e di fornire comunque energia al sistema dall'esterno in maniera casuale.

Un requisito importante è avere una struttura con un andamento di potenziale a dente di sega, in cui la distanza tra un massimo e il minimo successivo sia minore che nel verso opposto. Inoltre, deve essere presente un meccanismo frenante e una sorgente di energia casuale.

Alcuni esempi di meccanismi del genere sono le pompe ioniche cellulari: queste consistono, di solito, in una proteina a forma di imbuto, che alterna una configurazione a canale chiuso, in cui lo ione è fortemente accoppiato al canale, a una a canale aperto, in cui lo ione interagisce debolmente con il canale. Il moto browniano delle molecole è allora sufficiente a spingere lo ione in senso contrario al gradiente elettrochimico. Il passaggio da uno stato all'altro viene effettuato, di solito, grazie alla combustione di una molecola di Adenosina trifosfato (ATP).

Simulazione di nottolino termico[modifica | modifica sorgente]

Tutto questo sembra poco probabile, eppure è possibile simularne gli effetti con un semplice gioco "da tavolo". Ipotizziamo una serie di 5 caselle alternate, bianche e nere. La pedina, all'inizio posta al centro, si sposta in base al risultato del lancio di due dadi e del colore della casella di partenza. Per vincere, occorre uscire dallo scacchiere avanzando. Si perde se si esce retrocedendo.

Ad esempio:

Mossa Bianco Nero
Avanti 7, 11 11
Indietro 2, 3, 12 2, 4, 12

Lanciando 2 dadi, abbiamo 6 possibilità che venga 7, 2 che esca 11, 1 per il 12 e il 2, 2 per il 3, 3 per il 4.

Iniziamo con la pedina sul nero al centro. Le probabilità di vincere sono il prodotto delle possibilità di andare avanti dal bianco al nero, moltiplicate per quelle in avanti dal nero al bianco: dunque 8 \times 2 = 16. Le possibilità di perdere sono invece 5 \times 4 = 20. Si perde dunque 100 volte ogni 80 vittorie.

Supponiamo ora di avere un altro insieme di regole:

Mossa Bianco Nero
Avanti 11 7, 11
Indietro 2, 4, 12 2, 3, 12

Le probabilità di vittoria sono le stesse. Ora facciamo intervenire il processo casuale: applichiamo ora le une o le altre regole ogni volta in base al risultato del lancio di una moneta (testa o croce). Se ricalcoliamo le probabilità di vittoria, risultano allora il prodotto della media delle mosse in avanti dal bianco per quelle di mosse in avanti dal nero:

\frac{8+2}{2} \times \frac{8+2}{2} = 25.

Quelle di sconfitta, in modo simile, saranno

\frac{4+5}{2} \times \frac{4+5}{2} = 20{,}25.

Otteniamo quindi 81 sconfitte ogni 100 vittorie!

Listato C++ per un programma di simulazione[modifica | modifica sorgente]

È possibile simulare il processo attraverso un algoritmo. Il seguente listato è un programma in C++ che simula 100.000 partite al gioco, con una serie di 30 caselle (per modificare questi parametri, basta cambiare i valori delle variabili partite_da_giocare e Dimensione).

Si può sperimentare che si ottiene la vittoria circa 71 volte su 100, anche se si parte dalla casella 15, in cui bastano 14 passi per perdere mentre ne servono 15 per vincere.

 /* codice */ 
 /* Copyright BlakWolf 2004 */
 /* Released under Gnu GPL V. 2 or later, at your option */
 
 #include <set> /* contenitore per regole */
 #include <cstdlib> /* rand() e srand() */
 #include <ctime> /* time() */
 #include <iostream>
 
 /* 
 * Pedina
 * contiene la posizione sulla scacchiera 
 */
 struct Pedina {
  unsigned int posizione;
 };
 
 /*
 * Regola 
 * associa un risultato del dado
 * ad uno spostamento
 * */
 struct Regola {
  unsigned int Lancio;
  int Spostamento;
  Regola( const unsigned int& lancio, const int& spostamento) :
       Lancio(lancio),
       Spostamento(spostamento) {}
 inline bool operator< (const Regola& r) const {
   return (Lancio < r.Lancio);
 }
 inline bool operator== (const Regola& r) const {
   return (Lancio == r.Lancio);
 }
 
 };
 
 /* Insieme di regole
 * Contiene un insieme di regole del gioco
 * e le applica in funzione del tiro del dado 
 */
 class Ruleset {
 public:
  typedef std::set<Regola> Container;
  typedef Container::iterator Iterator;
 
 private:
  Container regole;
 
 public:
  Ruleset(Iterator from, Iterator to);
  int Applica(unsigned int& Lancio);
  ~Ruleset(){};
 };
 
 /* Inserisce le regole nel contenitore
 */
 Ruleset::Ruleset(Ruleset::Iterator from, Ruleset::Iterator to){
  for (Iterator it = from; it != to; ++it)
     regole.insert(*it);
 }
 
 /* Se trova una regola la applica, e ritorna lo spostamento
 * altrimenti ritorna 0 (spostamento nullo)
 */
 int Ruleset::Applica(unsigned int& Lancio){
  Iterator it = regole.find(Regola(Lancio, 0)) ;
  if (it == regole.end())
     return 0;
  return (it->Spostamento);
  }
 
 int main() {
 
  unsigned int Dimensione = 30; /* lunghezza del percorso */
  int partite_da_giocare = 100000; /* partite */
 
  int Croce;
  unsigned int Lancio;
 
  Ruleset::Container Contenitore;
 
  // set n. 1 di regole per i quadrati pari
  // se escono 7 o 11, avanza di 1, se escono 2 3 12 indietreggia di 1
 
  Contenitore.insert(Regola(7, 1));
  Contenitore.insert(Regola(11, 1));
  Contenitore.insert(Regola(2, -1));
  Contenitore.insert(Regola(3, -1));
  Contenitore.insert(Regola(12, -1));
 
  Ruleset Bianchi_a(Contenitore.begin(), Contenitore.end());
 
  // set n. 1 di regole per i quadrati dispari
  // vedi sopra
 
  Contenitore.clear();
  Contenitore.insert(Regola(11, 1));
  Contenitore.insert(Regola(2, -1));
  Contenitore.insert(Regola(4, -1));
  Contenitore.insert(Regola(12, -1));
 
  Ruleset Neri_a(Contenitore.begin(), Contenitore.end());
 
  // set n. 2 di regole per i quadrati pari
  Contenitore.clear();
  Contenitore.insert(Regola(11, 1));
  Contenitore.insert(Regola(2, -1));
  Contenitore.insert(Regola(4, -1));
  Contenitore.insert(Regola(12, -1));
 
  Ruleset Bianchi_b(Contenitore.begin(), Contenitore.end());
 
  // set n. 2 di regole per i quadrati dispari
  Contenitore.clear();
  Contenitore.insert(Regola(7, 1));
  Contenitore.insert(Regola(11, 1));
  Contenitore.insert(Regola(2, -1));
  Contenitore.insert(Regola(3, -1));
  Contenitore.insert(Regola(12, -1));
 
  Ruleset Neri_b(Contenitore.begin(), Contenitore.end());
 
  int Contatore = 0; // partite giocate
  int Vittorie = 0;  // partite vinte
 
  Pedina p;
  p.posizione = Dimensione / 2 ; /* Inizia la partita con la pedina al 
  centro */
  std::srand(std::time(0)); /* Randomizzazione del seme */
 
  while (Contatore < partite_da_giocare){
      Croce = (std::rand()>>8) & 1; // pari o dispari
      Lancio  = (std::rand()>>8) % 6 + 1; // dado 1
      Lancio += (std::rand()>>8) % 6 + 1; // dado 2
 
      if (Croce) { /* Esce Croce */
         if (p.posizione & 1) { /* Casella Dispari */
            p.posizione += Bianchi_a.Applica(Lancio);
         } else  /* Casella Pari */
            p.posizione += Neri_a.Applica(Lancio);
       } else {  /* Esce testa */
         if (p.posizione & 1) { /* Casella Dispari */
            p.posizione += Bianchi_b.Applica(Lancio);
         } else /* Casella Pari */
            p.posizione += Neri_b.Applica(Lancio);
       }
 
       if (p.posizione == Dimensione) { /* vittoria */
         p.posizione = Dimensione / 2; /* Rimetti il pedone al centro */
         ++Vittorie;
         ++Contatore;
         }
 
       if (p.posizione == 0) {  /* sconfitta */
         p.posizione = Dimensione / 2;
         ++Contatore;
       }
  }
 
  std::cout << "Vittorie " << Vittorie << " Giocate " << Contatore << "(";  
  std::cout << 100. * Vittorie / Contatore << "%)" << std::endl; 
  }
 
 /* fine codice  */

Realizzazione di nottolini quantistici[modifica | modifica sorgente]

Nottolino quantistico

Spostando il discorso sul piano della fisica dei quanti, i componenti di un nottolino quantistico diventano l'interferenza tra le funzioni d'onda, la quantizzazione dei livelli energetici e l'effetto tunnel. Linke e i suoi colleghi hanno utilizzato allo scopo dei punti quantici triangolari. Questi consistono in buche di potenziale, in cui gli elettroni hanno difficoltà a passare per il vertice.

Ad alta temperatura, gli elettroni si comportano all'incirca come nottolini browniani, in modo simile agli ioni nelle pompe molecolari: sottoposti ad un potenziale oscillante, fluiscono dal vertice e generano dunque una corrente anche se il potenziale medio è nullo. A bassa temperatura, invece, il meccanismo si comporta come un nottolino quantistico: gli elettroni fluiscono dai lati del triangolo in quanto il gap di energia necessario a superare l'ostacolo per effetto tunnel è minore in quella direzione.

Utilizzi pratici[modifica | modifica sorgente]

Motori molecolari[modifica | modifica sorgente]

Realizzare motori di dimensioni molecolari richiede un ripensamento del concetto di funzionamento: nei motori macroscopici, l'energia viene utilizzata per produrre un movimento utile al motore, mentre in campo molecolare si devono bloccare quelli inutili nel caos delle agitazioni termiche o delle interferenze probabilistiche.

Dispositivi elettronici[modifica | modifica sorgente]

La possibilità di gestire singoli elettroni, pur con i limiti descritti in precedenza, senza dover calibrare con altrettanta precisione i campi, offre molte possibilità all'elettronica di precisione, come la realizzazione di pompe di elettroni per la nanoelettronica, o l'amplificazione dei segnali lungo cavi di dimensioni molecolari. Inoltre i nottolini quantistici possono essere impiegati per moderare i vortici di corrente all'interno dei superconduttori, problema fondamentale per la realizzazione di magneti e cavi a superconduzione.

Bibliografia[modifica | modifica sorgente]

  • Manfred Eigen e Ruthild Winkler, The Laws of the Game, Princeton University Press, 1993
  • R. Dean Astumian, Da molecole a motori, Le Scienze 396, agosto 2001
  • Fabio Marchesoni, Dal moto perpetuo ai motori browniani, Le Scienze 435, novembre 2004

Voci correlate[modifica | modifica sorgente]