Intermediate Corrected Student Solution

• Intermediate corrected student solutions are automated methods that convert erroneous submissions into minimally altered versions using dynamic equivalence clustering and precise expression matching.
• They employ local repairs and ILP-based global optimization to ensure variable mappings align, resulting in small yet effective modifications that support educational feedback.
• Empirical studies demonstrate high repair coverage, rapid feedback generation, and scalability in MOOC environments, highlighting their impact on automated grading systems.

An intermediate corrected student solution is the outcome of a process that transforms an erroneous student submission into a minimally modified version that both aligns with a set of correct references and provides actionable feedback for further improvement. In computational education research, this concept is tightly linked to the algorithmic identification and correction of student programming or mathematical mistakes by leveraging large corpora of correct solutions, dynamic equivalence analysis, and constraint optimization. Modern frameworks perform this transformation efficiently to scale feedback and grading in contexts such as MOOCs, automated programming assignments, and mathematical problem solving.

1. Dynamic Equivalence Clustering of Correct Solutions

The process begins with clustering existing correct student solutions using dynamic equivalence criteria. This involves grouping solutions that, possibly differing in syntax, exhibit identical control-flow and variable behaviors on a finite test input set. Consider two submissions $P$ and $Q$; the matching is defined as:

$$P \sim_{I} Q \text{ iff } \exists \pi : V_Q \rightarrow V_P$$

$$\forall (\ell, v),\quad U_P(\ell, v) \sim_{I,\pi} U_Q(\ell, \pi^{-1}(v))$$

where $U_P$ and $U_Q$ map program locations to expressions, and $\sim_{I,\pi}$ indicates that behaviors (traces) are equivalent under variable mapping $\pi$ across the input set $I$. The clusters formed are equivalence classes under this relation, each with a representative $P_C$ and the set of cluster expressions $E_C(\ell, v)$ corresponding to all possible correct updates at each program location and variable.

This clustering ensures the repair mechanism can flexibly select from a wide array of correct expressions matching the student’s control-flow and variable assignment patterns.

2. Local Repairs via Expression Matching and Variable Relations

Given an incorrect attempt, the system first confirms that the control-flow structure matches that of one or more cluster representatives (efficient for most MOOC submissions). At each location $\ell$ and for each implementation variable $v_{\text{impl}}$, with implementation expression $e_{\text{impl}} = U(\ell, v_{\text{impl}})$, the system attempts to map $v_{\text{impl}}$ to a cluster variable $v_C$ and substitute $e_{\text{impl}}$ with $e_C$ from the representative solution, generating a repaired expression $e_{\text{repaired}}$ such that:

$e_C \sim_{I,\pi} e_{\text{repaired}}$

If $e_{\text{impl}}$ already matches, a trivial repair (cost zero) is selected. Repair size is quantified by the sum of tree edit distances between original and repaired expressions:

$$\text{cost}(R) = \sum_{(\ell, v)} \text{diff}\left( e_{\text{impl}}(\ell, v), e_{\text{repaired}}(\ell, v) \right)$$

This metric guides the selection of minimal and pedagogically meaningful edits.

3. Global Repair via ILP Constraint Optimization

Multiple local repairs may yield incompatible variable mappings or overlapping changes. To resolve this, a Zero-One Integer Linear Program (ILP) is formulated where:

• Variables $x_{v_1v_2}$ encode whether $v_1 \in V_{P_C}$ maps to $v_2 \in V_{\text{impl}}$
• Constraints enforce bijective mappings for all variables:

$$\forall v_1 \in V_{P_C}: \sum_{v_2 \in V_{\text{impl}}} x_{v_1v_2} = 1$$

$$\forall v_2 \in V_{\text{impl}}: \sum_{v_1 \in V_{P_C}} x_{v_1v_2} = 1$$

• For each available local repair $r$, a Boolean decision variable $x_r$ is introduced.
• The objective minimizes total repair cost:

$$\text{minimize}\quad O = \sum_{r} \text{cost}(r) \cdot x_r$$

ILP solution yields a globally consistent repair $R$ that aligns the student program with a correct solution with minimal edit cost, subject to variable mapping constraints.

4. Experimental Performance, Quality, and Feedback

Empirical evaluation on over 17,000 student attempts demonstrates that:

• The algorithm can generate program repairs for approximately 97% of incorrect submissions.
• Of these, 81% are small, high-quality repairs (tree edit distance ratio $<$ 0.3), indicating localized and meaningful fixes.
• Most repairs are synthesized in 3–5 seconds per submission.
• In interactive teaching environments, average feedback generation time is 8 seconds, supporting real-time usage.
• Manual inspection corroborates the pedagogical utility: large and overzealous repairs are rare, which avoids misleading students.

User studies report an average usefulness rating of 3.4 (on a 1–5 scale), with participants recognizing the benefit of scalable automated feedback.

5. Adaptability, Extensions, and Limitations

The repair algorithm is robust to differences in student variable usage. It supports:

• Addition of “fresh” variables (symbol $★$) when the reference solution requires variables not present in the student’s version.
• Deletion of extraneous variables (symbol $-$) when the student introduces unused state.
• This makes the system “complete” and applicable even in cases of variable set mismatches.

A noted limitation is the requirement for control-flow correspondence between the submission and the reference solution. Mismatches are rare but represent a frontier for algorithmic extension. The current cost function relies on syntax-based tree edit distance, suggesting future improvement could leverage semantic roles to more accurately capture pedagogically relevant transformations.

6. Integration, Scalability, and Educational Significance

The algorithm is designed for integration into educational infrastructure, particularly MOOC platforms with thousands of students. Its efficiency and reliance on dynamically clustered correct solutions enable:

• Immediate and automatic feedback without instructor intervention on each individual submission.
• Data-driven improvement over time, as the clustering of new solutions expands the repertoire of repairable cases.
• Utilization of the “wisdom of the crowd”: correct solutions clustered from diverse students support a broad set of common and edge-case errors in new submissions.

This strategy builds on accumulated student data, enhancing both grading consistency and the educational experience by guiding students towards correct solutions via minimally invasive and context-sensitive corrections.

7. Formal Summary and Mathematical Foundations

Let $R$ be the repair for incorrect program $P_{\text{impl}}$ with respect to reference $P_C$ under input set $I$. The repair cost is:

$$\text{cost}(R) = \sum_{(\ell,v)} \text{diff}\left( U(\ell,v), e_{\text{repaired}}(\ell,v) \right)$$

Consistency between repairs is formalized via:

$$\sum_{v_2 \in V_{\text{impl}}} x_{v_1v_2} = 1 \quad \forall v_1 \in V_{P_C}$$

and similar for $v_2$. These constraints ensure a bijective mapping between variables. The overall process achieves effective and scalable intermediate correction of student submissions using rigorous optimization over dynamically clustered solution pools, as validated by quantitative repair coverage, repair size histograms, and instructor/student usability studies.

This methodological approach has become foundational for the automation of feedback and grading in programming education, leveraging crowd-sourced patterns to generate small, natural, and contextually relevant repairs.