How LearningLemur questions work

In LearningLemur, a question is a structured system that combines content, expected answers, and evaluation rules to determine how student responses are interpreted and graded. Understanding how these elements interact helps teachers design reliable questions and control how answers are evaluated.

What It Is

In LearningLemur, a question comprises several interconnected components that define both what students see and how their responses are processed. Each question includes the following elements:

Statement

The statement defines the problem that students must solve. It should clearly describe the task and include all the information needed to answer the question. Depending on the use case, the statement may include:

• Text instructions.
• Numerical values.
• Mathematical expressions.
• Variables (for randomized questions).

You can use the MathType editor to insert mathematical notation directly into the statement.

The statement presents the problem, but it does not specify how answers will be evaluated.

Answers

The answers define the expected responses and the scoring criteria. Depending on the question type:

• In open-answer questions, answers are mathematical expressions.
• In multiple-choice questions, answers are predefined options.

Each answer can include:

• A score (e.g., 100%, partial credit).
• Optional feedback.
• Specific evaluation settings.

Evaluation options

The Evaluation options determine how student responses are compared to the defined answers. These rules control aspects such as:

• Whether answers must match exactly or can be mathematically equivalent.
• Whether simplified forms are required.
• Whether approximate values are accepted (tolerance).
• How units are interpreted.

Evaluation is defined per answer, meaning different answers can use different rules.

Question settings (optional)

The Question settings allow you to configure advanced behaviour and extend how a question is generated and evaluated. This section includes options such as:

• Random variables, to generate dynamic values.
• Constants and functions, to define reusable elements.
• Units of measure and prefixes, to control how units are interpreted.
• Allowed constructions, to restrict the types of expressions students can enter.
• Separator symbols, to define input formatting rules.

These settings enable you to create more flexible, controlled, and dynamic questions.

Why It Matters

Understanding how questions work is essential for designing effective assessments. A clear configuration allows teachers to:

• Control how strict or flexible the evaluation should be.
• Avoid unexpected grading results.
• Create dynamic questions with multiple variations.
• Provide meaningful feedback to students.

Without this understanding, questions may behave differently than intended, especially when using features such as randomization, tolerance, or multiple answers.

How It Works

When a student interacts with a question, LearningLemur processes it through a sequence of stages.

Stage 1: Variable generation.
If the question uses randomization, the system generates values for all random variables.

Stage 2: Expression evaluation.
The system computes all random expressions based on the generated variables. These expressions may define:

• The correct answer.
• Intermediate values.
• Distractors.

Stage 3: Answer definition.
The system evaluates the configured answers, which may reference variables or expressions. Each answer includes:

• A value or expression.
• A score.
• Optional feedback.
• Specific evaluation settings.

Stage 4: Response evaluation.
The student's response is compared against the defined answers using the configured evaluation rules. These rules determine:

• Whether answers must match exactly or be mathematically equivalent.
• Whether simplified forms are required.
• Whether approximate values are accepted.
• How units are interpreted.

Stage 5: Feedback and scoring.

The system assigns a score based on the matched answer and displays any associated feedback.

Key Rules or Behaviours

• Evaluation is defined per answer, meaning different answers can use different rules (for example, different tolerance or scoring).
• The statement does not affect grading. Only the answers and their evaluation settings determine how responses are evaluated.
• Random variables are generated before random expressions are evaluated.
• Random expressions are computed before answers are checked.
• Answers can reference variables and expressions (for example, #sol), allowing dynamic evaluation.
• Multiple answers can represent different levels of correctness (for example, full score and partial credit).
• The selected question type determines how students interact with the question (input vs selection), but not the underlying evaluation logic.

Examples

Example 1:
A teacher creates a randomized open-answer question:

• Variables a and b are generated.
• The expression sol = sqrt(a^2 + b^2) is evaluated.
• The answer is defined as #sol cm
• The student's response is compared using the evaluation rules.

Each student receives a different version of the question, but the evaluation follows the same logic.

Example 2:
A teacher creates a multiple-choice question:

• Answer options are predefined.
• Each option has an associated score.
• When the student selects an option, the system assigns the corresponding score.
• Feedback is displayed based on the selected answer.

Common Misunderstandings

Misconception: The statement determines how the answer is graded.
Clarification: The statement only presents the problem. Grading is defined by the answers and evaluation rules.

Misconception: All answers in a question use the same evaluation settings.
Clarification: Evaluation is defined per answer, so different answers can behave differently.

Misconception: Random variables and expressions are evaluated at the same time.
Clarification: Variables are generated first, and expressions are computed afterward using those values.

Misconception: Answers must be written as fixed values.
Clarification: Answers can reference variables and expressions (e.g., #sol), enabling dynamic, reusable question logic.

Related Concepts

• Understanding Question Types in LearningLemur
• Understanding the Open Answer Question Interface
• Understanding the Multiple Choice Question Interface