WOLFRAM

Wolfram Language & System Documentation Center
"HeldExpression" (Comparison Method)

"HeldExpression" (Comparison Method)

Compare expressions without evaluation.

Details

  • The "HeldExpression" comparison method considers two expressions to be equivalent if they are the same within any holding wrappers.
  • Both answer key values and submitted answers are typically provided with a holding wrapper such as Hold, HoldPattern or HoldComplete.
  • Answer key values containing patterns must be given using HoldPattern[expr] to support standard pattern matching. Using HoldComplete or Hold requires literal matching of expressions.

Examples

open all close all

Basic Examples  (2)

Create an AssessmentFunction for an unevaluated expression:

Wolfram Language code: heldtest = AssessmentFunction[Hold[Nest[f, x, 3]], "HeldExpression"]

The submitted answer must exactly match:

Wolfram Language code: heldtest[Hold[Nest[f, x, 3]]]

The evaluated result is not marked as correct:

Wolfram Language code: heldtest[Hold[f[f[f[x]]]]]

Create an AssessmentFunction for an unevaluated mathematical expression:

Wolfram Language code: heldmath = AssessmentFunction[Hold[1 + 2], "HeldExpression"]

The submitted answer must be identical:

Wolfram Language code: heldmath[Hold[1 + 2]]

Mathematically equivalent submissions that are not identical are marked incorrect:

Wolfram Language code: heldmath[Hold[2 + 1]]
Wolfram Language code: heldmath[Hold[3]]

Scope  (1)

Create an assessment function for a code question:

Wolfram Language code: rangetest = AssessmentFunction[Hold[Range /@ Range[4]], "HeldExpression"]

Use it in a QuestionObject:

Wolfram Language code: qo = QuestionObject[QuestionInterface["Code", "Use only Range and Map to create this output: {{1},{1,2},{1,2,3},{1,2,3,4}}"], rangetest]

Give the correct answer:

Wolfram Language code: qo

Attempting to submit the output will be marked as incorrect:

Wolfram Language code: qo

Properties & Relations  (4)

Assessment functions using Hold will treat patterns literally:

Wolfram Language code: holdassess = AssessmentFunction[Hold[Nest[f, x, _]], "HeldExpression"]

Submissions that match the pattern will be marked as incorrect:

Wolfram Language code: holdassess[Hold[Nest[f, x, 2]]]

Exact literal matches are marked as correct:

Wolfram Language code: holdassess[Hold[Nest[f, x, _]]]

Use HoldPattern instead to support pattern matching:

Wolfram Language code: holdpatternassess = AssessmentFunction[HoldPattern[Nest[f, x, _]], "HeldExpression"]

Matching held expressions are marked as correct:

Wolfram Language code: holdpatternassess[Hold[Nest[f, x, 2]]]

The evaluated result is not accepted:

Wolfram Language code: holdpatternassess[Hold[f[f[x]]]]

The "Expression" comparison method compares the full expression, including holding wrappers when they exist:

Wolfram Language code: exprcomp = AssessmentFunction[HoldPattern[_ + 2], "Expression"]

Different holding wrappers will not be marked as correct:

Wolfram Language code: exprcomp[Hold[1 + 2]]

Use "HeldExpression" to compare the expression within the holding wrapper:

Wolfram Language code: heldexprcomp = AssessmentFunction[HoldPattern[_ + 2], "HeldExpression"]

The same answer is marked correct:

Wolfram Language code: heldexprcomp[Hold[1 + 2]]

Create assessment for a held mathematical expression:

Wolfram Language code: holdaf = AssessmentFunction[Hold[1 + 2 + 3], "HeldExpression"]

Create another assessment for treating the same answer as an "ArithmeticResult":

Wolfram Language code: mathaf = AssessmentFunction[Hold[1 + 2 + 3], "ArithmeticResult"]

"HeldExpression" does not allow even basic equivalences like reordering terms in addition, but "ArithmeticResult" does:

Wolfram Language code: holdaf[Hold[3 + 1 + 2]]
Wolfram Language code: mathaf[Hold[3 + 1 + 2]]

Create assessment for a held code expression:

Wolfram Language code: holdaf = AssessmentFunction[HoldPattern[Table[i ^ 2, {i, RandomInteger[10]}]], "HeldExpression"]

Create another assessment for treating the same answer as a "CodeEquivalence" solution:

Wolfram Language code: codeaf = AssessmentFunction[HoldPattern[Table[i ^ 2, {i, RandomInteger[10]}]], "CodeEquivalence"]

"HeldExpression" does not attempt to find equivalences between non-identical answers, but "CodeEquivalence" does:

Wolfram Language code: holdaf[HoldPattern[# ^ 2& /@ Range[RandomInteger[10]]]]
Wolfram Language code: codeaf[HoldPattern[# ^ 2& /@ Range[RandomInteger[10]]]]

Possible Issues  (1)

QuestionObject allows formatting of values even when given in Hold wrappers:

Wolfram Language code: QuestionObject["Which creates a 2D display of values", AssessmentFunction[{Hold[Grid[{{a, b}, {c, d}}]] -> 1, Hold[Table[{{a, b}, {c, d}}, 1]], Hold[{Row@{a, b}, Row@{c, d}}]}, "HeldExpression"]]

Use DisableFormatting to prevent formatting in QuestionObject:

Wolfram Language code: QuestionObject["Which creates a 2D display of values", AssessmentFunction[{Hold[DisableFormatting@Grid[{{a, b}, {c, d}}]] -> 1, Hold[Table[{{a, b}, {c, d}}, 1]], Hold[DisableFormatting@{Row@{a, b}, Row@{c, d}}]}, "HeldExpression"]]