Частичная оценка в Mathematica

С проблемой, которую вы описываете, я не вижу прямого способа сделать это. Одна вещь, которую вы могли бы сделать, чтобы переделать его, чтобы сделать его значительно проще, - это переопределить A, чтобы он был функцией производных от F и G. Если у вас есть

A[{dFdx_,dFdy_}, {dGdx_,dGdy_}] := dFdx*dFdy 

вы будете в очень хорошем положении, чтобы вычислить производные от F, которые вам нужны, а затем определить AF способом, который является общим по отношению к A, например так:

With[{ dFdx = D[F,x], dFdy = D[F,y] },
  AF[G_] := A[{dFdx, dFdy}, {D[G, x], D[G, y]}]]

Вы можете использовать With для замены оцененных частей в неоцененной правой части формы SetDelayed (определение с использованием ":="), как показано. Однако, если вы не сможете внести это изменение, все станет запутанным, и вам придется сделать некоторые предположения о том, что такое A.

Если A является символом с определенными для него значениями DownValues ​​и имеет простое определение, то вы можете выполнить частичную оценку, которую хотите, используя Hold, выполнив замену правил, а затем выполнив ReleaseHold, например:

ReleaseHold[
  Hold[AF[G_] := A[F, G]] /. DownValues[A] /. 
    HoldPattern[D[F, var_]] :> With[{eval = D[F, var]}, eval /; True]]

Бит With[...] во втором правиле — это уловка для принудительной оценки чего-то, соответствующего шаблону внутри Hold, называемого "метод Тротта-Стшебонского", малопонятный, но чрезвычайно полезный для подобных задач. Однако этот путь действительно ограничивает ваш интерфейс, а это означает, что вы не можете, скажем, передать чистую функцию для A, а с более сложным определением этот трюк, вероятно, тоже не сработает. Если вам удастся указать, что ваша дифференциальная форма будет функцией реальных производных, я настоятельно рекомендую это сделать.

EDIT: я придумал более общий и надежный способ сделать это.

Хитрость заключается в том, чтобы временно подавить определение D (оператор производной) с помощью Block, чтобы производные в определении A остались невычисленными, а затем использовать замену правил, чтобы подставить значения для производных от F, одновременно завершая все. в чистой функции, чтобы получить правильную замену имени, например:

With[{fRules =
 {HoldPattern[D[F, x]] :> Evaluate[D[F, x]]}},
   Block[{D},
     With[{fn = Function[G, Evaluate[A[F, G] /. fRules]]},
       AF[G_] := fn[G]]]]

Разве вы не можете просто сделать:

A[F_] := With[{DF = D[F, x]}, Function[{G}, DF D[G, y]]]

Это похоже на каррирование в реальном функциональном языке программирования, таком как F#, где вы должны написать:

let a f =
  let df = d f x
  fun g -> df * d g y