Wolfram Blog
Brad Janes
Peter Falloon
Jeremy Stratton-Smith
The WolframAlpha Chemistry Team

Wolfram|Alpha Notebook Edition Turns One: Now with Support for Chemistry, Demonstrations and More

September 11, 2020
Brad Janes, Wolfram|Alpha Math Content Manager
Peter Falloon, Data & Semantics Engineering
Jeremy Stratton-Smith, Math Developer, Wolfram|Alpha Math Content
The WolframAlpha Chemistry Team

Wolfram|Alpha Notebook Edition Turns One: Now with Support for Chemistry, Demonstrations and More

Wolfram|Alpha Notebook Edition was released nearly a year ago, and we’re proud to share what the team has been working on since. In addition to the improvements made to Wolfram|Alpha itself, new input and output suggestions were added. There were parsing fixes, additions to the Wolfram|Alpha-to-Wolfram Language translation and some of the normal improvements one would expect. There are also some bigger features and interesting new capabilities that we will explore in a bit more detail here.

If you haven’t checked out Wolfram|Alpha Notebook Edition in a while, we’d like to invite you to revisit. With education looking a little different for many people right now, this could be a great time to explore this exciting new way to interface with Wolfram technologies.

One of the most useful features of any notebook-based computational environment is the ability to reuse the result of a prior calculation as the input to a new one. Using this, computations can be built up using an intuitive “step-by-step” approach and the need for cutting/pasting or retyping is reduced. In Wolfram|Alpha Notebook Edition, previous outputs can be referenced in a variety of ways, ranging from familiar Wolfram Language constructs such as %n or Out[n] to natural language expressions such as “simplify the last result,” “plot the above” or “square it.” In certain cases, an explicit reference needn’t even appear: e.g. if you input “y = sin(x^3)” followed by “make a plot,” Wolfram|Alpha Notebook Edition will infer that you want to make a plot of the previous equation. This functionality, which has been under continuous development since the release of this product, has recently been extended to leverage the powerful semantic capabilities that power the Suggestions Bar. This allows for context-dependent tailoring of results containing references to previous outputs based on the semantic types of those results. As we build out this functionality, you can expect to see Wolfram|Alpha Notebook Edition becoming even smarter in helping you to build up your computations.

Next is an example of a chain of inputs covering topics through a first-semester calculus course.

Compute a simple limit. If no value to approach is specified, the default is 0.

lim x^2/(1 - cos(x))
&#10005


Cell[CellGroupData[{Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "lim x^2/(1 - cos(x))", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[$CellContext`x^2/(1 - Cos[$CellContext`x]), $CellContext`x ->
      0]], "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[
          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[
      0.97, "limits", "", {{"min limit", HoldComplete[

          MinLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }, {
        "max limit", HoldComplete[

          MaxLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }}],
      Predictions`InInput}, {
     "InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          DiscreteLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          DiscreteLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$TrigAlgebra",
      Predictions`Prediction[
      0.5, "trigonometry", "", {{"expand trig functions", HoldComplete[
          Limit[

           TrigExpand[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "factor trig functions", HoldComplete[
          Limit[

           TrigFactor[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "reduce trig products and powers", HoldComplete[
          Limit[

           TrigReduce[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "convert trig functions to exponentials", HoldComplete[
          Limit[

           TrigToExp[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }}],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[
       HoldComplete,
        Hold[$CellContext`x^2/(1 - Cos[$CellContext`x])]]& ],
      Predictions`InInput}, {"InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.5, "properties", "", {{"function domain", HoldComplete[

          FunctionDomain[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x}]]& }, {
        "function range", HoldComplete[

          FunctionRange[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x}, {$CellContext`y}]]& \
}}], Predictions`InInput}, {"InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points",
       Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "InflectionPoints"][$CellContext`x^2/(1 -
          Cos[$CellContext`x]),
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[

          Integrate[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[

          Integrate[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[
      0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == $CellContext`x^2/(1 -
          Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$Rotate90",
      Predictions`Prediction[
      0.5, "trigonometry", "make trig function arguments imaginary",
       HoldComplete[
        Limit[(Complex[0, 1] $CellContext`x)^2/(1 - Cos[
         Complex[0, 1] $CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {"InputMathOperation$PlotFunction",
      Predictions`Prediction[
      0.5, "plotting", "plot function", HoldComplete[
        Plot[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, \
-21.2057504117311026448`3., 21.2057504117311026448`3.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[

        HoldComplete[
         Solve[$CellContext`x^2/(1 - Cos[$CellContext`x]) == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$ComplementTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry",
       "replace trig functions by their cofunctions", HoldComplete[
        Limit[$CellContext`x^2/(1 -
         Sin[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {
     "InputMathOperation$InverseTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry", "replace trig functions by their inverses",
        HoldComplete[
        Limit[$CellContext`x^2/(1 -
         ArcCos[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {
     "InputMathOperation$ReciprocalTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry",
       "replace trig functions by their reciprocals", HoldComplete[
        Limit[$CellContext`x^2/(1 -
         Sec[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {"InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points",
       Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "StationaryPoints"][$CellContext`x^2/(1 -
          Cos[$CellContext`x]),
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline]}],
       HoldComplete[
        D[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline]}],
       HoldComplete[
        Integrate[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {
     "InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`x], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
           BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[

         D[$CellContext`x^2/(1 -
          Cos[$CellContext`x]), $CellContext`x], $CellContext`x ->
         0]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series",
       Row[{"series expansion at ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
           BaselinePosition -> Baseline]}], HoldComplete[
        Series[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, 0, 5}]]& ],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {44., 20.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[2]:=",
 CellID->673659406],

Cell[BoxData[
 RowBox[{"Limit", "[",
  RowBox[{
   RowBox[{
    RowBox[{"x", "^", "2"}], "/",
    RowBox[{"(",
     RowBox[{"1", " ", "-", " ",
      RowBox[{"Cos", "[", "x", "]"}]}], ")"}]}], ",", " ",
   RowBox[{"x", " ", "->", " ", "0"}]}], "]"}]], "DeployedWLInput",
 CellChangeTimes->{3.807873027370891*^9},
 CellLabel->"In[2]:=",
 CellID->476579879]
}, Open  ]]

Define a function, such as .

set f(x) equal x^2/(1-cos(x))
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set f(x) equal x^2/(1-cos(x))", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`f[
       Pattern[$CellContext`x,
        Blank[]]] := $CellContext`x^2/(1 - Cos[$CellContext`x])],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[11]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[2]:=",
 CellID->294391203]
 

Users can refer to when further investigating its behavior.

limit of f(x) as x goes to Pi
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "limit of f(x) as x goes to Pi", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[
      $CellContext`f[$CellContext`x], $CellContext`x -> Pi]],
   "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[0.97, "limits", "", {{"min limit", HoldComplete[
          MinLimit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi]]& }, {
        "max limit", HoldComplete[
          MaxLimit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi]]& }}],
      Predictions`InInput}, {"InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          DiscreteLimit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          DiscreteLimit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         $CellContext`f[$CellContext`x]]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.5, "properties", "", {{"function domain", HoldComplete[
          FunctionDomain[
           $CellContext`f[$CellContext`x], {$CellContext`x}]]& }, {
        "function range", HoldComplete[
          FunctionRange[
           $CellContext`f[$CellContext`x], {$CellContext`x}, \
{$CellContext`y}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["InflectionPoints"][
          $CellContext`f[$CellContext`x],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[
           $CellContext`f[$CellContext`x], {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[
           $CellContext`f[$CellContext`x], {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == $CellContext`f[$CellContext`x], \
$CellContext`x]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Plot[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, -21.2057504117311026448`3.,
          21.2057504117311026448`3.}]]& ], Predictions`InInput}, {
     "InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[$CellContext`f[$CellContext`x] == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["StationaryPoints"][
          $CellContext`f[$CellContext`x],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[
         $CellContext`f[$CellContext`x], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[
         $CellContext`f[$CellContext`x], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`x], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[Pi], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[
         D[
          $CellContext`f[$CellContext`x], $CellContext`x], $CellContext`x ->
         Pi]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series", "", {{
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           $CellContext`f[$CellContext`x], {$CellContext`x, 0, 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[Pi], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           $CellContext`f[$CellContext`x], {$CellContext`x, Pi, 5}]]& }}],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[11]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[3]:=",
 CellID->1705528146]
 

Quickly plot the computed limit and .

plot this and f(x)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot this and f(x)", "assumptions" -> {}, "parse" -> Defer[
     Plot[{Pi^2/2,
       $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}, Evaluated ->
      True]], "inputpredictions" -> {{"InputMathOperation$AlternativePlot",
      Predictions`Prediction[0.99, "plotting", "", {{"log plot", HoldComplete[
          LogPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }, {"log-log plot", HoldComplete[
          LogLogPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }, {"log-linear plot", HoldComplete[
          LogLinearPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }}], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.9299999999999999, "properties", "function domain", HoldComplete[
        FunctionDomain[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x}]]& ],
      Predictions`InInput}, {"InputMathOperation$AreaBetweenCurves",
      Predictions`Prediction[
      0.91, "applications of calculus", "area between curves", HoldComplete[
        ResourceFunction["AreaBetweenCurves"][{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}]]& ],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[{Pi^2/2,
          $CellContext`f[$CellContext`x]}]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$IntegrateOverPlotRange",
      Predictions`Prediction[
      0.5, "integration", "integrate over plot range", HoldComplete[
        Integrate[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, $CellContext`x]]& ],
      Predictions`InInput}}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[13]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[4]:=",
 CellID->348012345]
 

Use the limit of the difference quotient to compute the derivative of .

limit
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "limit (f(x+h) - f(x))/h as h->0", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]],
   "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[0.97, "limits", "", {{"min limit", HoldComplete[

          MinLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]]& }, {
        "max limit", HoldComplete[

          MaxLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]]& }}],
      Predictions`InInput}, {"InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          DiscreteLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          DiscreteLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[0.5, "properties", "function domain", HoldComplete[
        FunctionDomain[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x}]]& ],
      Predictions`InInput}, {"InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "InflectionPoints"][($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h,
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[

          Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[

          Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == ($CellContext`f[$CellContext`x + \
$CellContext`h] - $CellContext`f[$CellContext`x])/$CellContext`h, \
$CellContext`x]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Manipulate[
         Plot[$CellContext`h^(-1) ((-$CellContext`x^2)/(1 -
            Cos[$CellContext`x]) + ($CellContext`h + $CellContext`x)^2/(1 -
            Cos[$CellContext`h + $CellContext`x])), {$CellContext`x, \
-2.2882456112707374452`3.,
           2.2882456112707374452`3.}], {$CellContext`h, \
-5.7071067811865479058`3., 5.7071067811865479058`3.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "StationaryPoints"][($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h,
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`h], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[
         D[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h], \
$CellContext`h -> 0]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series",
       Row[{"series expansion at ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Series[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x, 0, 5}]]& ],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->2029885181]
 

Verify.

is this equal to f'(x)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "is this equal to f'(x)", "assumptions" -> {}, "parse" -> Defer[
     TrueQ[
      Simplify[Out[-1] == Derivative[1][$CellContext`f][$CellContext`x]]]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[2]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[6]:=",
 CellID->118336516]
 

Let us build up another chain of queries, starting with a challenge problem from the Math Olympiad competition. The problem states:

Math Olympiad

First, set up a definition that defines the sequence.

set a(n)=a(n-1)+a(n-2)+a(n-3)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set a(n)=a(n-1)+a(n-2)+a(n-3)", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`a[
       Pattern[$CellContext`n,
        Blank[]]] := $CellContext`a[$CellContext`n -
        1] + $CellContext`a[$CellContext`n -
        2] + $CellContext`a[$CellContext`n - 3]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[4]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[68]:=",
 CellID->550316403]
 

Next, initialize the given values.

set a(1)=1, a(2)=2, a(3)=3
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set a(1)=1, a(2)=2, a(3)=3", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`a[1] = 1; $CellContext`a[2] = 2; $CellContext`a[3] = 3],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[69]:=",
 CellID->2143246125]
 

To make sure that Wolfram|Alpha Notebook Edition is interpreting everything in the expected way, try evaluating the next element in the sequence.

a(4)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "a(4)", "assumptions" -> {}, "parse" -> Defer[
     $CellContext`a[4]], "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
    "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[78]:=",
 CellID->2095238551]
 

You can also test your function to see if it matches your intuition, here adding together the given initial values for and , plus your computed value for .

does a[5] = 2+3+6
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "does a[5] = 2+3+6", "assumptions" -> {}, "parse" -> Defer[
     TrueQ[
      Simplify[$CellContext`a[5] == 2 + 3 + 6]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[5]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[77]:=",
 CellID->1776498819]
 

Finally, evaluate the sum to answer the initial question.

sum a(i) from i = 1 to 25
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "sum a(i) from i = 1 to 25", "assumptions" -> {}, "parse" -> Defer[
     Sum[
      $CellContext`a[$CellContext`i], {$CellContext`i, 1, 25}]],
   "inputpredictions" -> {{"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.99, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         $CellContext`a[$CellContext`i]]]& ], Predictions`InInput}, {
     "InputMathOperation$TestConvergence",
      Predictions`Prediction[
      0.54, "sums and products", "test for convergence", HoldComplete[
        SumConvergence[
         $CellContext`a[$CellContext`i], $CellContext`i]]& ],
      Predictions`InInput}, {"InputMathOperation$SumAbsoluteValues",
      Predictions`Prediction[
      0.52, "sums and products", "sum absolute values", HoldComplete[
        Sum[
         Abs[
          $CellContext`a[$CellContext`i]], {$CellContext`i, 1, 25}]]& ],
      Predictions`InInput}, {"InputMathOperation$TableOfSummands",
      Predictions`Prediction[0.51, "sums and products", "", {{
         Row[{"list of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Table[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 6}]]& }, {
         Row[{"table of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Grid[
           Prepend[
            Table[{$CellContext`i,
              $CellContext`a[$CellContext`i]}, {$CellContext`i, 1, 6}], {
             HoldForm[$CellContext`i],
             HoldForm[
              $CellContext`a[$CellContext`i]]}],
           Dividers -> {2 -> True, 2 -> True}]]& }, {
         Row[{"plot of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          ListPlot[
           Table[
            $CellContext`a[$CellContext`i], {$CellContext`i, 1, 6}], PlotRange ->
           All]]& }}], Predictions`InInput}, {
     "InputMathOperation$DiscreteLimitOfSum",
      Predictions`Prediction[0.5, "limits",
       Row[{"discrete limit as ",
         Pane[
          Style[
           HoldForm[$CellContext`i], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline],
         "->\[Infinity]"}], HoldComplete[
        DiscreteLimit[
         $CellContext`a[$CellContext`i], $CellContext`i -> Infinity]]& ],
      Predictions`InInput}, {"InputMathOperation$LimitOfSum",
      Predictions`Prediction[0.49, "limits",
       Row[{"limit as ",
         Pane[
          Style[
           HoldForm[$CellContext`i], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], "->",
         Pane[
          Style[
           HoldForm[25], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Limit[
         $CellContext`a[$CellContext`i], $CellContext`i -> 25]]& ],
      Predictions`InInput}, {"InputMathOperation$SwapSumAndProduct",
      Predictions`Prediction[
      0.48, "sums and products", "product of summands", HoldComplete[
        Product[
         $CellContext`a[$CellContext`i], {$CellContext`i, 1, 25}]]& ],
      Predictions`InInput}, {"InputMathOperation$ChangeUpperBound",
      Predictions`Prediction[0.47, "sums and products", "", {{
         Row[{"increase upper bound to ",
           Pane[
            Style[
             HoldForm[50], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Sum[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 50}]]& }, {
         Row[{"decrease upper bound to ",
           Pane[
            Style[
             HoldForm[12], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Sum[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 12}]]& }}],
      Predictions`InInput}}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[65]:=",
 CellID->1495082103]
 

These are the same steps that a computer science student might take to solve such a problem, but no computer language or coding was required. Only simple natural language statements were used to set up, test and solve the desired problem.

One of the aspects of Wolfram|Alpha Notebook Edition that has been greatly expanded over the past year is the use of resource functions that are developed and submitted by staff members. Similar to what Bob expressed in his recent blog post, we are also fans of the Wolfram Function Repository and have been hard at work making useful tools more accessible. These functions, while submitted by internal staff, go through the exact same review process as that of externally submitted resource functions, and are all publicly accessible via the Function Repository. With the release of Wolfram|Alpha Notebook Edition, the challenge arose of concisely representing the many highly specific kinds of computations that are available through the many pods returned for an input in Wolfram|Alpha.

For example, a topic frequently covered in calculus classes is calculating the arc length of a curve, say given some bounds. This is easily done in the Wolfram Language by running the following:

ArcLength
&#10005

ArcLength[x^2, {x, 0, 1}]

This acts as a bit of a black box to students who may be asked to set up an integral and then evaluate it. Through the use of resource functions, Wolfram|Alpha Notebook Edition is able to do this exactly.

arc length of x^2 for 0<x<1
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "arc length of x^2 for 0 {}", "parse" -> Defer[
     ResourceFunction["ArcLengthIntegral"][$CellContext`x^2, {$CellContext`x, 0, 1}]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->1121786887]
 

evaluate that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "evaluate that", "assumptions" -> {}, "parse" -> Defer[
     Integrate[
      Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]],
   "inputpredictions" -> {{
     "InputMathOperation$PlotFunctionWithIntegralDefinite",
      Predictions`Prediction[
      0.99, "plotting", "plot function and integral", HoldComplete[
        Plot[{(1 + 4 $CellContext`x^2)^
          Rational[
           1, 2], (Rational[1, 2] $CellContext`x) (1 + 4 $CellContext`x^2)^
            Rational[1, 2] +
          Rational[1, 4] ArcSinh[2 $CellContext`x]}, {$CellContext`x, 0, 1},
         PlotLegends -> {"f", "\[Integral]f"}]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotOverIntegralRange",
      Predictions`Prediction[
      0.98, "plotting", "plot function over integral range", HoldComplete[
        Plot[
         Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.97, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$Derivatives",
      Predictions`Prediction[0.96, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.95, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         Sqrt[1 + 4 $CellContext`x^2]]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.9299999999999999, "properties", "", {{"function domain", HoldComplete[
          FunctionDomain[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x}]]& }, {
        "function range", HoldComplete[
          FunctionRange[
           Sqrt[
           1 + 4 $CellContext`x^2], {$CellContext`x}, {$CellContext`y}]]& }}],
      Predictions`InInput}, {"InputMathOperation$Discontinuities",
      Predictions`Prediction[
      0.5, "analysis", "discontinuities", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["FunctionDiscontinuities"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["InflectionPoints"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y ==
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Plot[(1 + 4 $CellContext`x^2)^
         Rational[1, 2], {$CellContext`x, -16.9866666666666681351`3.,
          16.9866666666666681351`3.}]]& ], Predictions`InInput}, {
     "InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[Sqrt[1 + 4 $CellContext`x^2] == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["StationaryPoints"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$AlternativePowers",
      Predictions`Prediction[
      0.5, "algebra", "", {{"substitute square for power", HoldComplete[
          Integrate[(1 + 4 $CellContext`x^2)^2, {$CellContext`x, 0, 1}]]& }, {
        "substitute square root for power", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]]& }, {
        "substitute cube root for power", HoldComplete[

          Integrate[(1 + 4 $CellContext`x^2)^(1/3), {$CellContext`x, 0,
            1}]]& }}], Predictions`InInput}, {
     "InputMathOperation$IntegralAverage",
      Predictions`Prediction[0.5, "integration",
       Row[{"average value of function on ",
         Pane[
          Style[
           HoldForm["[0, 1]"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[Integrate[
          Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]/(1 + 0)]& ],
      Predictions`InInput}, {"InputMathOperation$EvaluateIntegrandAtLimits",
      Predictions`Prediction[0.5, "integration", "", {{
         Row[{"evaluate integrand at ",
           Pane[
            Style[
             HoldForm["x = 0"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          ReplaceAll[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x -> 0}]]& }, {
         Row[{"evaluate integrand at ",
           Pane[
            Style[
             HoldForm["x = 1"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          ReplaceAll[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x -> 1}]]& }}],
      Predictions`InInput}, {"InputMathOperation$Limits",
      Predictions`Prediction[0.5, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$Series",
      Predictions`Prediction[0.5, "series", "", {{
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              Complex[0,
               Rational[-1, 2]]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            Complex[0,
             Rational[-1, 2]], 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              Complex[0,
               Rational[1, 2]]], LineBreakWithin -> False], ImageSize -> {150},
             BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            Complex[0,
             Rational[1, 2]], 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[1], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 1, 5}]]& }}],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[27]:=",
 CellID->398998877]
 

While this may seem like a number of extra steps, it fills a pedagogical role in granting students the ability to, in some way, peek under the hood of math that otherwise is so efficiently done with built-in functions.

The use of resource functions in Wolfram|Alpha Notebook Edition also eases the transition into learning Wolfram Language syntax that might be a stumbling block for students and educators new to Wolfram technologies. One example of this is the setup of an interactive plot to visualize the scaling and translation of a function as you vary parameters—something not possible on the web at this time.

b + Sin[a*x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot b+Sin[a x] varying a and b from 0 to 2", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction[
     "ManipulatePlot"][$CellContext`b +
      Sin[$CellContext`a $CellContext`x], {$CellContext`x, -5.4,
       5.4}, {{$CellContext`a, 1}, 0, 2}, {{$CellContext`b, 1}, 0, 2}]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[20]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->923091347]
 

Seeing the Wolfram Language interpretation of this input introduces users to the syntax of this ManipulatePlot function so they might be able to build up something more complicated themselves, and also introduces them to Wolfram Language syntax proper. This highlights one of the key elements of the development of resource functions for use in Wolfram|Alpha Notebook Edition: creating highly functional code that does specific tasks that might not fit within the overall Wolfram Language. Such functions provide easy access points to high-level content that is particularly useful in the education world. Another key question in this development process is how to represent all of the information that is accessible from a single input to Wolfram|Alpha. Consider the information accessible from a simple input “sin(x)”. There are resource functions (and corresponding Wolfram|Alpha Notebook Edition inputs) like the following, which not only produce similar information, but can also present it in interactive ways to build intuition and understanding.

function overview Sin[x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "function overview Sin[x]", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction["FunctionOverview"][
      Sin[$CellContext`x], $CellContext`x, Reals, Dataset]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[2]:=",
 CellID->169532030]
 

curve analysis sin[x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "curve analysis sin[x]", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["CurveAnalysis"][
      Sin[$CellContext`x], $CellContext`x]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[7]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->188415816]
 

As seen here, through the use of high-level resource functions, Wolfram|Alpha Notebook Edition is able to serve content similar to Wolfram|Alpha, but reformatted and restructured for the desktop environment.

Our implementation of the Wolfram Function Repository functions goes beyond purely mathematical exploits. Here, we can generate an image.

image of a cat
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "image of a cat", "assumptions" -> {}, "parse" -> Defer[
     Entity["Species", "Species:FelisCatus"][
      EntityProperty["Species", "Image"]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "cat", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "2"}, {
         XMLElement[
         "value", {
          "name" -> "Species", "desc" -> "a species specification", "input" ->
           "*C.cat-_*Species-"}, {}],
         XMLElement[
         "value", {
          "name" -> "CatBreedClass", "desc" -> " referring to cat breeds",
           "input" -> "*C.cat-_*CatBreedClass-"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {79., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[11]:=",
 CellID->1402703484]
 

We can then perform some image processing analysis by interpreting the image in various ways.

dog vision of that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "dog vision of that", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["SimulateAnimalVision"]["Dog",
      Out[-1]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[4]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[12]:=",
 CellID->2117594833]
 

Of course, the opposite is possible as well.

cat vision of dog image
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "cat vision of a dog image", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["SimulateAnimalVision"]["Cat",
      Entity["Species", "Infraspecies:CanisLupusFamiliaris"][
       EntityProperty["Species", "Image"]]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[42]:=",
 CellID->1107810711]
 

There are many other popular Wolfram|Alpha domains that are now directly supported in Wolfram|Alpha Notebook Edition.

orbit of halley's comet
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "orbit of halley's comet", "assumptions" -> {}, "parse" -> Defer[
     WolframAlphaResult[
     "orbit of halley's comet", {{"SolarSystemConfiguration:CometData", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use \"${word2}\" as ${desc2}. Use \
\"${word3}\" as ${desc3}.", "count" -> "3"}, {
         XMLElement[
         "value", {"name" -> "CometPropertyClass", "word" -> "orbit", "desc" ->
           "orbital properties of a comet", "input" ->
           "*MC.%7E-_*CometPropertyClass-"}, {}],
         XMLElement[
         "value", {"name" -> "CometProperty", "word" -> "orbit", "desc" ->
           "orbit circumference of a comet", "input" -> "*MC.%7E-_*CometProperty-"}, {}],
         XMLElement[
         "value", {"name" -> "Formula", "word" -> "", "desc" -> "a formula", "input" ->
           "*MC.%7E-_*Formula-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[9]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->1602796222]
 

Polaris sky chart from Seattle on 9/13/2020
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Polaris sky chart from Seattle on 9/13/2020", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction["SkyChart"][
      Entity["Star", "Polaris"],
      Entity["City", {"Seattle", "Washington", "UnitedStates"}]["Position"],
      DateObject[{2020, 9, 13}]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use \"${word2}\" as ${desc2}.",
         "count" -> "2"}, {
         XMLElement[
         "value", {"name" -> "TimeSeriesPhrase", "word" -> "chart", "desc" ->
           " referring to a calendar computation", "input" ->
           "*MC.sky+chart-_*TimeSeriesPhrase-"}, {}],
         XMLElement[
         "value", {"name" -> "StarPropertyClass", "word" -> "sky chart", "desc" ->
           "sky chart of a star", "input" ->
           "*MC.sky+chart-_*StarPropertyClass-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[14]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[28]:=",
 CellID->1583322521]
 

play sin(x*Floor(100x^2)) for 5 seconds
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "play sin(x*Floor(100x^2)) for 5 seconds", "assumptions" -> {},
   "parse" -> Defer[
     Play[
      Sin[$CellContext`x Floor[100 $CellContext`x^2]], {$CellContext`x,
       0.3203475194016502, 5.3203475194016505`}, SampleRate -> 44100]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[23]:=",
 CellID->287802117]
 

plot eternatus curve
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot eternatus curve", "assumptions" -> {}, "parse" -> Defer[
     Entity["PopularCurve", "EternatusCurve"][
      EntityProperty["PopularCurve", "Plot"]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[25]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellChangeTimes->{{3.8067485702832212`*^9, 3.8067485706277514`*^9}},
 CellLabel->"In[28]:=",
 CellID->1441622532]
 

make the background pink
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "make the background pink", "assumptions" -> {}, "parse" ->
   Defer[
     Show[
      Out[-1], Background -> Pink]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "SubCategory", "word" -> "pink", "template" ->
         "Assuming ${desc1}. Use ${desc2} instead", "count" -> "2"}, {
         XMLElement[
         "value", {
          "name" -> "{WolframLanguage, Pink}", "desc" -> "basic pink", "input" ->
           "*DPClash.ColorE.pink-_**WolframLanguage.Pink--"}, {}],
         XMLElement[
         "value", {
          "name" -> "{HTML, Pink}", "desc" -> "HTML pink", "input" ->
           "*DPClash.ColorE.pink-_**HTML.Pink--"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {79., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[29]:=",
 CellID->1665329757]
 

One of the major new content areas that we’ve added support for in Wolfram|Alpha Notebook Edition is chemistry. How does the Wolfram|Alpha chemistry team prioritize which chemistry problems to support? We try to maximize the breadth of support while focusing on topics that are encountered in middle-school, high-school and college chemistry courses. Currently, we are working our way toward buffer problems by building up the prerequisite topics of solution preparation:

Prepare a 0.02 M KOH solution
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Prepare a 0.02 M KOH solution", "assumptions" -> {}, "parse" ->
   Defer[
     WolframAlphaResult[
     "Prepare a 0.02 M KOH solution", {{"Result", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[12]:=",
 CellID->1597933442]
 

… chemical equation balancing:

Balance Oxalic acid
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" ->
   "Balance Oxalic acid (s) + water (l) -> hydronium ion (aq) + oxalate ion \
(aq)", "assumptions" -> {}, "parse" -> Defer[
     WolframAlphaResult[
     "Balance Oxalic acid (s) + water (l) -> hydronium ion (aq) + oxalate ion \
(aq)", {{"BalancedEquationPod:ChemicalReactionData", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[2]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[17]:=",
 CellID->2100650035]
 

… and construction of the equilibrium constant expression:

equilibrium constant acetic acid
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "equilibrium constant acetic acid (aq) + water (l) -> hydronium ion (aq) + acetate ion (aq)", "assumptions" -> {}, "parse" ->
   Defer[
     WolframAlphaResult[
     "equilibrium constant acetic acid (aq) + water (l) -> hydronium ion (aq) + acetate ion (aq)", {{
       "ReactionKineticsConstant:ChemicalReactionData", 1}, "Content"}, InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {"type" -> "SubCategory", "word" -> "acetate ion", "template" -> "Assuming ${desc1}. Use ${desc2} instead", "count" ->
         "2"}, {
         XMLElement[
         "value", {"name" -> "IonAcetate", "desc" -> "acetate anion", "input" ->
           "*DPClash.ChemicalIntermediateE.acetate+ion-_*IonAcetate-"}, {}],
         XMLElement[
         "value", {"name" -> "IonCyanide", "desc" -> "cyanide anion", "input" ->
           "*DPClash.ChemicalIntermediateE.acetate+ion-_*IonCyanide-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[5]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{496., {88., 30.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 CellMargins->{{100, 10}, {5, 10}},
 PrivateCellOptions->{"CellSettings"->{"HideDetails" -> FrontEnd`SuppressEvaluationHash[False]}},
 CellLabel->"In[81]:=",
 CellID->1455453525]
 

You can also see the step-by-step procedure of computing the previous chemistry results. We’ve also added support for the chemical capabilities newly added to the Wolfram Language in Version 12.

caffeine
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "caffeine", "assumptions" -> {}, "parse" -> Defer[
     Entity["Chemical", "Caffeine"]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "caffeine", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "4"}, {
         XMLElement[
         "value", {
          "name" -> "Chemical", "desc" -> "a chemical compound", "input" ->
           "*C.caffeine-_*Chemical-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Molecule", "desc" -> " referring to molecule", "input" ->
           "*C.caffeine-_*Molecule-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Word", "desc" -> "a word", "input" ->
           "*C.caffeine-_*Word-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Movie", "desc" -> "a movie", "input" ->
           "*C.caffeine-_*Movie-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[10]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->536225153]
 

molecule of that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "molecule of that", "assumptions" -> {}, "parse" -> Defer[
     Molecule[
      Out[-1]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[7]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[6]:=",
 CellID->352448835]
 

We are still building the kinds of chemical properties that work via session referencing, but many properties already work as a single-line input. These and more will be working via session referencing as well in the coming weeks.

(2R)-2-acetamido-3-methylbutanoic acid mesh region
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "(2R)-2-acetamido-3-methylbutanoic acid mesh region",
   "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["MoleculeMeshRegion"][
      Molecule["(2R)-2-acetamido-3-methylbutanoic acid"]]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[7]:=",
 CellID->4107428]
 

(2R)-2-acetamido-3-methylbutanoic acid principal moments of inertia
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" ->
   "(2R)-2-acetamido-3-methylbutanoic acid principal moments of inertia",
   "assumptions" -> {}, "parse" -> Defer[
     MoleculeValue[
      Molecule["(2R)-2-acetamido-3-methylbutanoic acid"], "PrincipalMoments"]],
    "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[8]:=",
 CellID->286397275]
 

Another tool in the Wolfram family that we have been able to add support for in Wolfram|Alpha Notebook Edition that is unavailable on the Wolfram|Alpha website is the Wolfram Demonstrations Project. In Wolfram|Alpha Notebook Edition, you can ask for a specific Demonstration by name. Clicking the entity blob will return the fully interactive Demonstration in a new window.

Mondrian Four-Coloring demonstration
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Mondrian Four-Coloring demonstration", "assumptions" -> {},
   "parse" -> Defer[
     Entity["WolframDemonstration", "MondrianFourColoring"]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[21]:=",
 CellID->287512350]
 

Mondrian Four-Coloring

You can also search Demonstrations by category if you are looking for a particular topic to, for instance, show off to your classroom. First, enter a query for Demonstrations of a particular category.

Derivatives demonstrations
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Derivatives demonstrations ", "assumptions" -> {}, "parse" ->
   Defer[
     EntityClass["WolframDemonstration", "Derivatives"]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use as ${desc2} instead. \
Use \"${word3}\" as ${desc3}.", "count" -> "3"}, {
         XMLElement[
         "value", {
          "name" -> "WolframDemonstrationClass", "word" -> "the input", "desc" ->
           " referring to wolfram demonstration data", "input" ->
           "*MC.%7E-_*WolframDemonstrationClass-"}, {}],
         XMLElement[
         "value", {
          "name" -> "WordData", "word" -> "the input", "desc" ->
           " referring to English words", "input" ->
           "*MC.%7E-_*WordData-"}, {}],
         XMLElement[
         "value", {
          "name" -> "MathWorld", "word" -> "Derivatives", "desc" ->
           " referring to a mathematical definition", "input" ->
           "*MC.%7E-_*MathWorld-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[9]:=",
 CellID->462304110]
 

The first item on the generated Suggestions Bar should be “entity list.” Click that to see the full EntityList of Demonstrations from that category.

EntityList
&#10005

EntityList[EntityClass["WolframDemonstration", "Derivatives"]]

Beyond the Demonstrations, there are more ways to use Wolfram|Alpha Notebook Edition as a learning tool. Entering in a generic topic will, just as with the Wolfram|Alpha website, return a page with examples. This similarly pops up in a new notebook, pre-filled with sample natural language inputs in the domain that you were asking about.

differential equations
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "differential equations", "assumptions" -> {}, "parse" ->
   XMLElement[
    "examplepage", {
     "category" -> "DifferentialEquations", "url" ->
      "https://www.current.wolframalpha.com/examples/DifferentialEquations-\
content.html"}, {}], "inputpredictions" -> {}, "otherpredictions" -> {},
   "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "differential equations", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "4"}, {
         XMLElement[
         "value", {
          "name" -> "ExamplePage", "desc" -> "a general topic", "input" ->
           "*C.differential+equations-_*ExamplePage-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Calculator", "desc" -> "a computation", "input" ->
           "*C.differential+equations-_*Calculator-"}, {}],
         XMLElement[
         "value", {
          "name" -> "MathWorld", "desc" ->
           " referring to a mathematical definition", "input" ->
           "*C.differential+equations-_*MathWorld-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Periodical", "desc" -> "a periodical", "input" ->
           "*C.differential+equations-_*Periodical-"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[61]:=",
 CellID->86442253]
 

Differential equations notebook

This will encourage further exploration, as you will still see the same input and output suggestions as you would with your own inputs. And speaking of example pages, a new project we’re working on that will be particularly useful for educators in the US is curated examples pages catered to the US Common Core Math Standards. An example of what that will look like follows, and we are planning on releasing pages for all the US standards in the coming months.

US Common Core Math Standards

Perhaps our latest and most exciting addition to the world of Wolfram|Alpha Notebook Edition is the migration of our Wolfram|Alpha notebook capabilities to the Wolfram Cloud. Now you can do all kinds of computational exploration from your browser. To access this feature, navigate to File > New > Wolfram|Alpha-Mode Notebook. You should see the familiar natural language input box, and you can now enter the same kinds of queries, view input and output suggestions and even interact with our Demonstrations and built-in Function Repository functions!

We are proud of the progress we have made in the last year, and we are especially encouraged by the number of people trying Wolfram|Alpha Notebook Edition and the kinds of computations that they are using it for. We hope it will continue to be a useful tool for students, educators, parents, independent researchers and enthusiasts. Please let us know what else you’d like to see in Wolfram|Alpha Notebook Edition!

Also keep an eye out for upcoming book releases from Wolfram Media:

  • Click here to receive updates about the third edition of Hands-on Start to Wolfram Mathematica and Programming with the Wolfram Language.
  • Click here to receive updates about Hands-on Start to Wolfram|Alpha Notebook Edition.
Want to give it a try? Sign up for a trial of Wolfram|Alpha Notebook Edition.

Leave a Comment

No Comments




Leave a comment