scoping lessicale e dinamica Mathematica: variabili locali con il modulo, con, e il Blocco

Question

Il codice seguente restituisce 14 come ci si aspetterebbe:

Block[{expr}, 
    expr = 2 z; 
    f[z_] = expr; 
    f[7]] 

Ma se si cambia che Block ad un Module poi ritorna 2*z . Sembra non importare quali altre variabili oltre a expr localizzate. Pensavo di aver capito Modulo, Blocco e Con in Mathematica ma non posso spiegare la differenza di comportamento tra Modulo e Blocco in questo esempio.

risorse correlate:

• Tutorial on Modularity and the Naming of Things dalla documentazione di Mathematica
• Estratto da un book by Paul R. Wellin, Richard J. Gaylord, and Samuel N. Kamin
• Explanation from Dave Withoff on the Mathematica newsgroup

PS: Grazie a Michael Pilat, Davorak e Bill White per seguire t Ha tracce di profumo su questa stranezza. Davorak chiarisce e arriva al nocciolo del problema qui: Why would Mathematica break normal scoping rules in Module?

Answer 1

Anche io ne sono rimasto un po 'sorpreso, ma non penso che sia un bug. Se si guarda in profondità negli esempi del reference page for Module, sotto la sezione denominata Possibili Problemi, c'è una piccola nota che dice "Variabili vengono rinominati in ambiti annidati" e fornisce il seguente esempio:

In[1]:= Module[{e = Expand[(1 + x)^5]}, Function[x, e]] 

Out[1]= Function[x$, e$1194] 

In[2]:= %[10] 

Out[2]= 1 + 5 x + 10 x^2 + 10 x^3 + 5 x^4 + x^5 

Function è un altro costrutto dell'ambito come Module, quindi x viene rinominato internamente allo x$ nell'ambito di Function, simile a quello che hai scoperto con Trace su z.

Nella tua Module definire f, Set è un altro tale costrutto scoping, e quindi z viene rinominato quando f è definito all'interno di un Module, ma non quando si trova all'interno di un Block. Seguendo il consiglio di quel esempio dalla documentazione Module, si può costruire la RHS della funzione dalle sue parti per evitare la ridenominazione lessicale del campo di applicazione nidificato:

In[3]:= Clear[f, z] 

In[4]:= Module[{expr}, 
    expr = 2 z; 
    Set @@ {f[z_], expr}; 
    f[7]] 

Out[4]= 14 

HTH!

Answer 2

Hai utilizzato Trace su entrambe le espressioni?

Answer 3

Prima di tutto, penso che tu abbia esposto un bug qui.

In secondo luogo, penso di poter offrire alcune informazioni sul perché questo sta accadendo, tenendo presente che la mia conoscenza degli aspetti interni della matematica è limitata.

un'istruzione come: f [z_]: = 2 z in forma completa è:

SetDelayed[f[Pattern[z, Blank[]]], 2 z] 

Questo imposta il DownValue [f] per:

{HoldPattern[f[z_]] :> 2 z} 

Poi più tardi quando un'espressione, come f [2], viene poi viene valutata qualcosa come segue viene preformato:

f[2] /. HoldPattern[f[z_]] :> 2 z 

il che valutare a 4. Ora, questo è tutto Po possibile perché la corrispondenza del modello sta avvenendo con Pattern [z, Blank []] dal primo blocco di codice. Funziona anche se hai impostato per sempre z su un numero. In altre parole.

z = 5; 
f[z_] := 2*z 

produce ancora le stesse downvalues ​​per f:

{HoldPattern[f[z_]] :> 2 z} 

Questo è possibile perché modello ha l'attributo HoldFirst.

L'attributo HoldFirst non è una protezione sufficiente se lo si valuta all'interno di un modulo. Esempio:

SetAttributes[tmp, HoldFirst]; 
Module[{expr}, 
expr = 2 z; 
tmp[expr] 
] 

uscite:

tmp[expr$8129] 

propongo perché HoldFirst Abilità non fornisce l'immunità a regola di riscrittura variabile del modulo che qualsiasi Modello in una regola che contiene una variabile locale hanno loro variabili modello riscritto . sym-> Simbolo [SymbolName [sym] ~~ "$"]

Module[{expr}, 
Hold[z_ -> (z; expr)] 
] 
(*Hold[z$_ -> (z$; expr$1391)]*) 

z ha essere riscritto su entrambi i lati della regola in una semplice conversione alfa.

Se la regola non contiene una variabile locale non riscrittura accade:

Module[{expr}, 
Hold[z_ -> (z)] 
] 
(*Hold[z_ -> z]*) 

Piuttosto che cercare di vedere se una variabile locale corrisponde una variabile regola viene applicata la regola di coperta sopra.

Quindi il problema è che l'espressione locale non viene valutata prima della conversione alpha. O forse sarebbe anche meglio avere expr racchiuso in una conversione alfa ponderata che sarebbe necessaria per un RuleDelayed.

Ciò non accade in Blocco perché il blocco non riscrive nessuna delle variabili locali.

Altre idee? Qualcuno vede buchi nella mia logica?