QuizGenerator 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py

@@ -4,8 +4,8 @@ import logging
 import math
 from typing import List
 
-from QuizGenerator.question import Question, QuestionRegistry, Answer
-from QuizGenerator.contentast import ContentAST
+from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
 from QuizGenerator.mixins import MathOperationQuestion
 
 log = logging.getLogger(__name__)
@@ -67,10 +67,8 @@ class VectorMathQuestion(MathOperationQuestion, Question):
     # Call parent refresh which will use our generate_operands method
     super().refresh(*args, **kwargs)
 
-    # For backward compatibility, set vector_a/vector_b for single questions
-    if not self.is_multipart():
-      self.vector_a = self.operand_a
-      self.vector_b = self.operand_b
+    self.vector_a = self.operand_a
+    self.vector_b = self.operand_b
 
   def generate_subquestion_data(self):
     """Generate LaTeX content for each subpart of the question.
@@ -117,121 +115,58 @@ class VectorAddition(VectorMathQuestion):
     return [vector_a[i] + vector_b[i] for i in range(len(vector_a))]
 
   def create_subquestion_answers(self, subpart_index, result):
-    letter = chr(ord('a') + subpart_index)
-    for j in range(len(result)):
-      self.answers[f"subpart_{letter}_{j}"] = Answer.integer(f"subpart_{letter}_{j}", result[j])
+    raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    # Backward compatibility - still populate dict for old pattern
-    for i in range(len(result)):
-      self.answers[f"result_{i}"] = Answer.integer(f"result_{i}", result[i])
-
-  def get_body(self):
-    """Override parent get_body() to use our custom formatting."""
-    body, _ = self._get_body()
-    return body
+    self.answers["result"] = AnswerTypes.Vector(result)
 
   def _get_body(self):
-    """Build question body and collect answers (new pattern)."""
-    from typing import Tuple, List
-
+    """Build question body and collect answers."""
     body = ContentAST.Section()
-    answers = []
 
     body.add_element(ContentAST.Paragraph([self.get_intro_text()]))
 
-    if self.is_multipart():
-      # Use multipart formatting with repeated problem parts
-      subpart_data = self.generate_subquestion_data()
-      repeated_part = self.create_repeated_problem_part(subpart_data)
-      body.add_element(repeated_part)
-
-      # Collect all subpart answers
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        result = data['result']
-        for j in range(len(result)):
-          ans = Answer.integer(f"subpart_{letter}_{j}", result[j])
-          answers.append(ans)
-    else:
-      # Single equation display using MathExpression for format-independent rendering
-      vector_a_elem = self._format_vector(self.vector_a)
-      vector_b_elem = self._format_vector(self.vector_b)
-      body.add_element(ContentAST.MathExpression([
-          vector_a_elem,
-          " + ",
-          vector_b_elem,
-          " = "
-      ]))
-
-      # Canvas-only answer fields (hidden from PDF)
-      body.add_element(ContentAST.OnlyHtml([ContentAST.Paragraph(["Enter your answer as a column vector:"])]))
-      table_data = []
-      for i in range(self.dimension):
-        ans = Answer.integer(f"result_{i}", self.result[i])
-        answers.append(ans)
-        table_data.append([ans])
-      body.add_element(ContentAST.OnlyHtml([ContentAST.Table(data=table_data, padding=True)]))
-
-    return body, answers
+    # Equation display using MathExpression for format-independent rendering
+    vector_a_elem = self._format_vector(self.vector_a)
+    vector_b_elem = self._format_vector(self.vector_b)
+    body.add_element(ContentAST.MathExpression([
+        vector_a_elem,
+        " + ",
+        vector_b_elem,
+        " = "
+    ]))
+
+    # Canvas-only answer field - use stored answer for consistent UUID
+    answer = self.answers["result"]
+    body.add_element(ContentAST.OnlyHtml([ContentAST.Paragraph(["Enter your answer as a column vector:"])]))
+    body.add_element(ContentAST.OnlyHtml([answer]))
+
+    return body, list(self.answers.values())
 
   def _get_explanation(self):
-    """Build question explanation (new pattern)."""
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph(["To add vectors, we add corresponding components:"]))
 
-    if self.is_multipart():
-      # Handle multipart explanations
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        vector_a = data['vector_a']
-        vector_b = data['vector_b']
-        result = data['result']
-
-        # Format vectors using Typst syntax
-        vector_a_str = self._format_vector(vector_a)
-        vector_b_str = self._format_vector(vector_b)
-        result_str = self._format_vector(result)
-
-        # Build addition step-by-step
-        addition_elements = "; ".join([f"{vector_a[j]}+{vector_b[j]}" for j in range(self.dimension)])
-        addition_str = f"mat({addition_elements})"
-
-        # Add explanation for this subpart
-        explanation.add_element(ContentAST.Paragraph([f"Part ({letter}):"]))
-        explanation.add_element(
-            ContentAST.Equation.make_block_equation__multiline_equals(
-                lhs="arrow(a) + arrow(b)",  # Typst uses arrow() for vectors
-                rhs=[
-                    f"{vector_a_str} + {vector_b_str}",
-                    addition_str,
-                    result_str
-                ]
-            )
+    # Use LaTeX syntax for make_block_equation__multiline_equals
+    vector_a_str = r" \\ ".join([str(v) for v in self.vector_a])
+    vector_b_str = r" \\ ".join([str(v) for v in self.vector_b])
+    result_str = r" \\ ".join([str(v) for v in self.result])
+    addition_str = r" \\ ".join([f"{self.vector_a[i]}+{self.vector_b[i]}" for i in range(self.dimension)])
+
+    explanation.add_element(
+        ContentAST.Equation.make_block_equation__multiline_equals(
+            lhs=r"\vec{a} + \vec{b}",
+            rhs=[
+                f"\\begin{{bmatrix}} {vector_a_str} \\end{{bmatrix}} + \\begin{{bmatrix}} {vector_b_str} \\end{{bmatrix}}",
+                f"\\begin{{bmatrix}} {addition_str} \\end{{bmatrix}}",
+                f"\\begin{{bmatrix}} {result_str} \\end{{bmatrix}}"
+            ]
         )
-    else:
-      # Single part explanation - use Typst syntax
-      vector_a_str = self._format_vector(self.vector_a)
-      vector_b_str = self._format_vector(self.vector_b)
-      result_str = self._format_vector(self.result)
-
-      # Build addition step-by-step
-      addition_elements = "; ".join([f"{self.vector_a[i]}+{self.vector_b[i]}" for i in range(self.dimension)])
-      addition_str = f"mat({addition_elements})"
-
-      explanation.add_element(
-          ContentAST.Equation.make_block_equation__multiline_equals(
-              lhs="arrow(a) + arrow(b)",
-              rhs=[
-                  f"{vector_a_str} + {vector_b_str}",
-                  addition_str,
-                  result_str
-              ]
-          )
-      )
+    )
 
-    return explanation, []  # Explanations don't have answers
+    return explanation, []
 
 
 @QuestionRegistry.register()
@@ -243,179 +178,70 @@ class VectorScalarMultiplication(VectorMathQuestion):
   def _generate_scalar(self):
     """Generate a non-zero scalar for multiplication."""
     scalar = self.rng.randint(-5, 5)
-    while scalar == 0:  # Avoid zero scalar for more interesting problems
+    while scalar == 0:
       scalar = self.rng.randint(-5, 5)
     return scalar
 
-  def generate_operands(self):
-    """Override to generate scalar and vector."""
-    if not hasattr(self, 'dimension'):
-      self.dimension = self.rng.randint(self.MIN_DIMENSION, self.MAX_DIMENSION)
-    vector_a = self._generate_vector(self.dimension)
-    vector_b = self._generate_vector(self.dimension)  # Not used, but kept for consistency
-    return vector_a, vector_b
-
   def refresh(self, *args, **kwargs):
-    if self.is_multipart():
-      # For multipart questions, we handle everything ourselves
-      # Don't call super() because we need different scalars per subpart
-
-      # Call Question.refresh() directly to get basic setup
-      Question.refresh(self, *args, **kwargs)
-
-      # Generate vector dimension
-      self.dimension = self.rng.randint(self.MIN_DIMENSION, self.MAX_DIMENSION)
-
-      # Clear any existing data
-      self.answers = {}
-
-      # Generate multiple subquestions with their own scalars
-      self.subquestion_data = []
-      for i in range(self.num_subquestions):
-        # Generate unique vectors and scalar for each subquestion
-        vector_a = self._generate_vector(self.dimension)
-        vector_b = self._generate_vector(self.dimension)  # Not used, but kept for consistency
-        scalar = self._generate_scalar()
-        result = [scalar * component for component in vector_a]
-
-        self.subquestion_data.append({
-          'operand_a': vector_a,
-          'operand_b': vector_b,
-          'vector_a': vector_a,
-          'vector_b': vector_b,
-          'scalar': scalar,
-          'result': result
-        })
-
-        # Create answers for this subpart
-        self.create_subquestion_answers(i, result)
-    else:
-      # For single questions, generate scalar first
-      self.scalar = self._generate_scalar()
-      # Then call super() normally
-      super().refresh(*args, **kwargs)
+    # Generate scalar first, then call parent refresh
+    self.scalar = self._generate_scalar()
+    super().refresh(*args, **kwargs)
 
   def get_operator(self):
     return f"{self.scalar} \\cdot"
 
   def calculate_single_result(self, vector_a, vector_b):
-    # For scalar multiplication, we only use vector_a and ignore vector_b
     return [self.scalar * component for component in vector_a]
 
   def create_subquestion_answers(self, subpart_index, result):
-    letter = chr(ord('a') + subpart_index)
-    for j in range(len(result)):
-      self.answers[f"subpart_{letter}_{j}"] = Answer.integer(f"subpart_{letter}_{j}", result[j])
+    raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    for i in range(len(result)):
-      self.answers[f"result_{i}"] = Answer.integer(f"result_{i}", result[i])
-
-  def generate_subquestion_data(self):
-    """Override to handle scalar multiplication format."""
-    subparts = []
-    for data in self.subquestion_data:
-      vector_elem = self._format_vector(data['vector_a'])
-      scalar = data['scalar']
-      # Return MathExpression for format-independent rendering
-      subparts.append(ContentAST.MathExpression([
-          f"{scalar} \\cdot ",
-          vector_elem
-      ], inline=True))
-    return subparts
-
-  def get_body(self):
-    """Override parent get_body() to use our custom formatting."""
-    body, _ = self._get_body()
-    return body
+    self.answers["result"] = AnswerTypes.Vector(result)
 
   def _get_body(self):
-    """Build question body and collect answers (new pattern)."""
+    """Build question body and collect answers."""
     body = ContentAST.Section()
-    answers = []
 
     body.add_element(ContentAST.Paragraph([self.get_intro_text()]))
 
-    if self.is_multipart():
-      # Use multipart formatting with repeated problem parts
-      subpart_data = self.generate_subquestion_data()
-      repeated_part = self.create_repeated_problem_part(subpart_data)
-      body.add_element(repeated_part)
-
-      # Collect all subpart answers
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        result = data['result']
-        for j in range(len(result)):
-          ans = Answer.integer(f"subpart_{letter}_{j}", result[j])
-          answers.append(ans)
-    else:
-      # Single equation display using MathExpression
-      vector_elem = self._format_vector(self.vector_a)
-      body.add_element(ContentAST.MathExpression([
-          f"{self.scalar} \\cdot ",
-          vector_elem,
-          " = "
-      ]))
-
-      # Canvas-only answer fields (hidden from PDF)
-      body.add_element(ContentAST.OnlyHtml([ContentAST.Paragraph(["Enter your answer as a column vector:"])]))
-      table_data = []
-      for i in range(self.dimension):
-        ans = Answer.integer(f"result_{i}", self.result[i])
-        answers.append(ans)
-        table_data.append([ans])
-      body.add_element(ContentAST.OnlyHtml([ContentAST.Table(data=table_data, padding=True)]))
-
-    return body, answers
+    # Equation display using MathExpression
+    vector_elem = self._format_vector(self.vector_a)
+    body.add_element(ContentAST.MathExpression([
+        f"{self.scalar} \\cdot ",
+        vector_elem,
+        " = "
+    ]))
+
+    # Canvas-only answer field - use stored answer
+    answer = self.answers["result"]
+    body.add_element(ContentAST.OnlyHtml([ContentAST.Paragraph(["Enter your answer as a column vector:"])]))
+    body.add_element(ContentAST.OnlyHtml([answer]))
+
+    return body, list(self.answers.values())
 
   def _get_explanation(self):
-    """Build question explanation (new pattern)."""
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph(["To multiply a vector by a scalar, we multiply each component by the scalar:"]))
 
-    if self.is_multipart():
-      # Handle multipart explanations
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        vector_a = data['vector_a']
-        result = data['result']
-        scalar = data['scalar']
-
-        # Use LaTeX syntax (will be converted by Equation._latex_to_typst for Typst output)
-        vector_str = r" \\ ".join([str(v) for v in vector_a])
-        multiplication_str = r" \\ ".join([f"{scalar} \\cdot {v}" for v in vector_a])
-        result_str = r" \\ ".join([str(v) for v in result])
-
-        explanation.add_element(ContentAST.Paragraph([f"Part ({letter}):"]))
-        explanation.add_element(
-            ContentAST.Equation.make_block_equation__multiline_equals(
-                lhs=f"{scalar} \\cdot \\vec{{v}}",
-                rhs=[
-                    f"{scalar} \\cdot \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}}",
-                    f"\\begin{{bmatrix}} {multiplication_str} \\end{{bmatrix}}",
-                    f"\\begin{{bmatrix}} {result_str} \\end{{bmatrix}}"
-                ]
-            )
+    vector_str = r" \\ ".join([str(v) for v in self.vector_a])
+    multiplication_str = r" \\ ".join([f"{self.scalar} \\cdot {v}" for v in self.vector_a])
+    result_str = r" \\ ".join([str(v) for v in self.result])
+
+    explanation.add_element(
+        ContentAST.Equation.make_block_equation__multiline_equals(
+            lhs=f"{self.scalar} \\cdot \\vec{{v}}",
+            rhs=[
+                f"{self.scalar} \\cdot \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}}",
+                f"\\begin{{bmatrix}} {multiplication_str} \\end{{bmatrix}}",
+                f"\\begin{{bmatrix}} {result_str} \\end{{bmatrix}}"
+            ]
         )
-    else:
-      vector_str = r" \\ ".join([str(v) for v in self.vector_a])
-      multiplication_str = r" \\ ".join([f"{self.scalar} \\cdot {v}" for v in self.vector_a])
-      result_str = r" \\ ".join([str(v) for v in self.result])
-
-      explanation.add_element(
-          ContentAST.Equation.make_block_equation__multiline_equals(
-              lhs=f"{self.scalar} \\cdot \\vec{{v}}",
-              rhs=[
-                  f"{self.scalar} \\cdot \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}}",
-                  f"\\begin{{bmatrix}} {multiplication_str} \\end{{bmatrix}}",
-                  f"\\begin{{bmatrix}} {result_str} \\end{{bmatrix}}"
-              ]
-          )
-      )
+    )
 
-    return explanation, []  # Explanations don't have answers
+    return explanation, []
 
 
 @QuestionRegistry.register()
@@ -431,101 +257,53 @@ class VectorDotProduct(VectorMathQuestion):
     return sum(vector_a[i] * vector_b[i] for i in range(len(vector_a)))
 
   def create_subquestion_answers(self, subpart_index, result):
-    letter = chr(ord('a') + subpart_index)
-    self.answers[f"subpart_{letter}"] = Answer.integer(f"subpart_{letter}", result)
+    raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    self.answers = {
-      "dot_product": Answer.integer("dot_product", result)
-    }
-
-  def get_body(self):
-    """Override parent get_body() to use our custom formatting."""
-    body, _ = self._get_body()
-    return body
+    self.answers["dot_product"] = AnswerTypes.Int(result)
 
   def _get_body(self):
-    """Build question body and collect answers (new pattern)."""
+    """Build question body and collect answers."""
     body = ContentAST.Section()
-    answers = []
 
     body.add_element(ContentAST.Paragraph([self.get_intro_text()]))
 
-    if self.is_multipart():
-      # Use multipart formatting with repeated problem parts
-      subpart_data = self.generate_subquestion_data()
-      repeated_part = self.create_repeated_problem_part(subpart_data)
-      body.add_element(repeated_part)
-
-      # Collect all subpart answers (scalar results)
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        result = data['result']
-        ans = Answer.integer(f"subpart_{letter}", result)
-        answers.append(ans)
-    else:
-      # Single equation display using MathExpression
-      vector_a_elem = self._format_vector(self.vector_a)
-      vector_b_elem = self._format_vector(self.vector_b)
-      body.add_element(ContentAST.MathExpression([
-          vector_a_elem,
-          " \\cdot ",
-          vector_b_elem,
-          " = "
-      ]))
-
-      # Canvas-only answer field (single scalar result)
-      ans = Answer.integer("dot_product", self.result)
-      answers.append(ans)
-      body.add_element(ContentAST.OnlyHtml([ans]))
-
-    return body, answers
+    # Equation display using MathExpression
+    vector_a_elem = self._format_vector(self.vector_a)
+    vector_b_elem = self._format_vector(self.vector_b)
+    body.add_element(ContentAST.MathExpression([
+        vector_a_elem,
+        " \\cdot ",
+        vector_b_elem,
+        " = "
+    ]))
+
+    # Canvas-only answer field - use stored answer
+    answer = self.answers["dot_product"]
+    body.add_element(ContentAST.OnlyHtml([answer]))
+
+    return body, list(self.answers.values())
 
   def _get_explanation(self):
-    """Build question explanation (new pattern)."""
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph(["The dot product is calculated by multiplying corresponding components and summing the results:"]))
 
-    if self.is_multipart():
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        vector_a = data['vector_a']
-        vector_b = data['vector_b']
-        result = data['result']
-
-        vector_a_str = r" \\ ".join([str(v) for v in vector_a])
-        vector_b_str = r" \\ ".join([str(v) for v in vector_b])
-        products_str = " + ".join([f"({vector_a[j]} \\cdot {vector_b[j]})" for j in range(self.dimension)])
-        calculation_str = " + ".join([str(vector_a[j] * vector_b[j]) for j in range(self.dimension)])
-
-        explanation.add_element(ContentAST.Paragraph([f"Part ({letter}):"]))
-        explanation.add_element(
-            ContentAST.Equation.make_block_equation__multiline_equals(
-                lhs="\\vec{a} \\cdot \\vec{b}",
-                rhs=[
-                    f"\\begin{{bmatrix}} {vector_a_str} \\end{{bmatrix}} \\cdot \\begin{{bmatrix}} {vector_b_str} \\end{{bmatrix}}",
-                    products_str,
-                    calculation_str,
-                    str(result)
-                ]
-            )
-        )
-    else:
-      vector_a_str = r" \\ ".join([str(v) for v in self.vector_a])
-      vector_b_str = r" \\ ".join([str(v) for v in self.vector_b])
-      products_str = " + ".join([f"({self.vector_a[i]} \\cdot {self.vector_b[i]})" for i in range(self.dimension)])
-      calculation_str = " + ".join([str(self.vector_a[i] * self.vector_b[i]) for i in range(self.dimension)])
-
-      explanation.add_element(
-          ContentAST.Equation.make_block_equation__multiline_equals(
-              lhs="\\vec{a} \\cdot \\vec{b}",
-              rhs=[
-                  f"\\begin{{bmatrix}} {vector_a_str} \\end{{bmatrix}} \\cdot \\begin{{bmatrix}} {vector_b_str} \\end{{bmatrix}}",
-                  products_str,
-                  calculation_str,
-                  str(self.result)
-              ]
+    vector_a_str = r" \\ ".join([str(v) for v in self.vector_a])
+    vector_b_str = r" \\ ".join([str(v) for v in self.vector_b])
+    products_str = " + ".join([f"({self.vector_a[i]} \\cdot {self.vector_b[i]})" for i in range(self.dimension)])
+    calculation_str = " + ".join([str(self.vector_a[i] * self.vector_b[i]) for i in range(self.dimension)])
+
+    explanation.add_element(
+        ContentAST.Equation.make_block_equation__multiline_equals(
+            lhs="\\vec{a} \\cdot \\vec{b}",
+            rhs=[
+                f"\\begin{{bmatrix}} {vector_a_str} \\end{{bmatrix}} \\cdot \\begin{{bmatrix}} {vector_b_str} \\end{{bmatrix}}",
+                products_str,
+                calculation_str,
+                str(self.result)
+            ]
           )
       )
 
@@ -539,136 +317,65 @@ class VectorMagnitude(VectorMathQuestion):
   MAX_DIMENSION = 3
 
   def get_operator(self):
-    # Magnitude uses ||...|| notation, not an operator between vectors
     return "||"
 
   def calculate_single_result(self, vector_a, vector_b):
-    # For magnitude, we only use vector_a and ignore vector_b
     magnitude_squared = sum(component ** 2 for component in vector_a)
     return math.sqrt(magnitude_squared)
 
   def create_subquestion_answers(self, subpart_index, result):
-    # Backward compatibility
-    letter = chr(ord('a') + subpart_index)
-    self.answers[f"subpart_{letter}"] = Answer.auto_float(f"subpart_{letter}", result)
+    raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    # Backward compatibility
-    self.answers = {
-      "magnitude": Answer.auto_float("magnitude", result)
-    }
-
-  def generate_subquestion_data(self):
-    """Override to handle magnitude format ||vector||.
-
-    Returns MathExpression elements for format-independent rendering.
-    """
-    subparts = []
-    for data in self.subquestion_data:
-      vector_elem = self._format_vector(data['vector_a'])
-      # Create MathExpression for ||vector||
-      subparts.append(ContentAST.MathExpression([
-          "||",
-          vector_elem,
-          "||"
-      ], inline=True))
-    return subparts
-
-  def get_body(self):
-    """Override parent get_body() to use our custom formatting."""
-    body, _ = self._get_body()
-    return body
+    self.answers["magnitude"] = AnswerTypes.Float(result)
 
   def _get_body(self):
-    """Build question body and collect answers (new pattern)."""
-    from typing import Tuple, List
-
+    """Build question body and collect answers."""
     body = ContentAST.Section()
-    answers = []
 
     body.add_element(ContentAST.Paragraph([self.get_intro_text()]))
 
-    if self.is_multipart():
-      # Use multipart formatting with repeated problem parts
-      subpart_data = self.generate_subquestion_data()
-      repeated_part = self.create_repeated_problem_part(subpart_data)
-      body.add_element(repeated_part)
-
-      # Collect all subpart answers
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        result = data['result']
-        ans = Answer.auto_float(f"subpart_{letter}", result)
-        answers.append(ans)
-    else:
-      # Single equation display using MathExpression for format-independent rendering
-      vector_elem = self._format_vector(self.vector_a)
-      body.add_element(ContentAST.MathExpression([
-          "||",
-          vector_elem,
-          "|| = "
-      ]))
-
-      # Canvas-only answer field (hidden from PDF)
-      ans = Answer.auto_float("magnitude", self.result)
-      answers.append(ans)
-      body.add_element(ContentAST.OnlyHtml([ans]))
-
-    return body, answers
+    # Equation display using MathExpression
+    vector_elem = self._format_vector(self.vector_a)
+    body.add_element(ContentAST.MathExpression([
+        "||",
+        vector_elem,
+        "|| = "
+    ]))
+
+    # Canvas-only answer field - use stored answer
+    answer = self.answers["magnitude"]
+    body.add_element(ContentAST.OnlyHtml([answer]))
+
+    return body, list(self.answers.values())
 
   def _get_explanation(self):
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph(["The magnitude of a vector is calculated using the formula:"]))
-    explanation.add_element(ContentAST.Equation("||arrow(v)|| = sqrt(v_1^2 + v_2^2 + ... + v_n^2)", inline=False))
-
-    if self.is_multipart():
-      # Handle multipart explanations
-      for i, data in enumerate(self.subquestion_data):
-        letter = chr(ord('a') + i)
-        vector_a = data['vector_a']
-        result = data['result']
-
-        # Format vectors using Typst syntax
-        vector_str = self._format_vector(vector_a)
-        squares_str = " + ".join([f"{v}^2" for v in vector_a])
-        calculation_str = " + ".join([str(v**2) for v in vector_a])
-        sum_of_squares = sum(component ** 2 for component in vector_a)
-        result_formatted = sorted(Answer.accepted_strings(result), key=lambda s: len(s))[0]
-
-        # Add explanation for this subpart
-        explanation.add_element(ContentAST.Paragraph([f"Part ({letter}):"]))
-        explanation.add_element(
-            ContentAST.Equation.make_block_equation__multiline_equals(
-                lhs="||arrow(v)||",
-                rhs=[
-                    f"||{vector_str}||",
-                    f"sqrt({squares_str})",
-                    f"sqrt({calculation_str})",
-                    f"sqrt({sum_of_squares})",
-                    result_formatted
-                ]
-            )
+    explanation.add_element(ContentAST.Equation(
+        r"||\vec{v}|| = \sqrt{v_1^2 + v_2^2 + \cdots + v_n^2}", inline=False
+    ))
+
+    # Use LaTeX syntax for make_block_equation__multiline_equals
+    vector_str = r" \\ ".join([str(v) for v in self.vector_a])
+    squares_str = " + ".join([f"{v}^2" for v in self.vector_a])
+    calculation_str = " + ".join([str(v**2) for v in self.vector_a])
+    sum_of_squares = sum(component ** 2 for component in self.vector_a)
+    result_formatted = sorted(ContentAST.Answer.accepted_strings(self.result), key=lambda s: len(s))[0]
+
+    explanation.add_element(
+        ContentAST.Equation.make_block_equation__multiline_equals(
+            lhs=r"||\vec{v}||",
+            rhs=[
+                f"\\left|\\left| \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}} \\right|\\right|",
+                f"\\sqrt{{{squares_str}}}",
+                f"\\sqrt{{{calculation_str}}}",
+                f"\\sqrt{{{sum_of_squares}}}",
+                result_formatted
+            ]
         )
-    else:
-      # Single part explanation - use Typst syntax
-      vector_str = self._format_vector(self.vector_a)
-      squares_str = " + ".join([f"{v}^2" for v in self.vector_a])
-      calculation_str = " + ".join([str(v**2) for v in self.vector_a])
-      sum_of_squares = sum(component ** 2 for component in self.vector_a)
-      result_formatted = sorted(Answer.accepted_strings(self.result), key=lambda s: len(s))[0]
-
-      explanation.add_element(
-          ContentAST.Equation.make_block_equation__multiline_equals(
-              lhs="||arrow(v)||",
-              rhs=[
-                  f"||{vector_str}||",
-                  f"sqrt({squares_str})",
-                  f"sqrt({calculation_str})",
-                  f"sqrt({sum_of_squares})",
-                  result_formatted
-              ]
-          )
-      )
+    )
 
-    return explanation, []  # Explanations don't have answers
+    return explanation, []