From bbaa458abc3617e63c9a1806164ca60db59be45c Mon Sep 17 00:00:00 2001
From: "Dobbertin, Niclas" <niclas.dobbertin@mailbox.org>
Date: Mon, 14 Oct 2024 14:08:48 +0200
Subject: update

---
 paper2/thesis.tex | 39 ++++++++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 17 deletions(-)

(limited to 'paper2/thesis.tex')

diff --git a/paper2/thesis.tex b/paper2/thesis.tex
index 36e1bd8..4fb4097 100644
--- a/paper2/thesis.tex
+++ b/paper2/thesis.tex
@@ -212,14 +212,6 @@ The testing phase always uses fixed order.
 
 
 How modeled:
-Improvements in task performance are mainly dependent on production compilation, as the order and how efficiently the mathematical operations are performed are the main subject of the task.
-Utility learning matters mostly on production selection and ordering, however the task itself is mostly linear.
-It can still play a significant role if alternative or shortcut productions for mathematical operations exist.
-E.g.\ a production that swaps argument 1 and argument 2 in addition or multiplication may reduce time spend, dependent on how the algorithm functions.
-
-The subsymbolic system of ACT-R also involves mechanisms to gauge retrieval chance and activation strength in the declarative memory.
-This is used to model learning and retrieval of new memory chunks.
-In this task however, the subject already has knowledge of mathematical facts and \todo{``not learn new facts really during exp''} \
 
 \begin{table}[hb]
 \caption{Experiment Procedures.}
@@ -260,9 +252,22 @@ The bottom procedure is always included as it calculates the total water quality
 
 \section*{Model}
 
+Improvements in task performance are mainly dependent on production compilation, as the order and how efficiently the mathematical operations are performed are the main subject of the task.
+Utility learning matters mostly on production selection and ordering, however the task itself is mostly linear.
+It can still play a significant role if alternative or shortcut productions for mathematical operations exist.
+E.g.\ a production that swaps argument 1 and argument 2 in addition or multiplication may reduce time spend, dependent on how the algorithm functions.
+
+The subsymbolic system of ACT-R also involves mechanisms to gauge retrieval chance and activation strength in the declarative memory.
+This is used to model learning and retrieval of new memory chunks.
+In this task however, the subject already has knowledge of mathematical facts and \todo{``not learn new facts really during exp''} \
+
+\subsection{Implementation}
 \todo[inline]{chunktypes, pre-knowledge}
-The model was made using the ACT-R architecture through the pyactr implementation.
-It has the subsymbolic system, production compilation and utility learning enabled. \todo{specify parameters}
+The model was made using the ACT-R architecture \citep{anderson2004} through the pyactr \citep{Brasoveanu_2020} implementation.
+The base model uses default parameters.
+To enable production compilation and utility learning, the parameters ``production\_compilation'' and ``utility\_learning'' have to be set to ``True''.
+Due to implementation details in pyactr, the subsymbolic system has to be enabled as well.
+Issues and workarounds when implementing the model will be reviewed in the Discussion.
 
 The model works with four different types of chunks specified.
 Number chunks hold the number, its digits and the number one higher.
@@ -284,7 +289,7 @@ User input and trial change is detected from the model trace.
 
 The model works through the tasks with a set of productions, which perform mathematical operations, search the screen, input answers and organize order of operations.
 
-\subsection*{Greater/Less-than Operation}
+\subsubsection*{Greater/Less-than Operation}
 \todo[inline]{Maybe better as figure note or in appx.\ and simpler/shorter description}
 
 This pair operations compares two multi-digit numbers and sets the greater/less number as answer.
@@ -294,7 +299,7 @@ That means that the productions comparing the tens can only fire if the hundreds
 The selected production now retrieves a comparison of the two digits from declarative memory.
 Depending on the result, either number 1 or number 2 will be written into the answer slot.
 
-\subsection*{Addition Operation}
+\subsubsection*{Addition Operation}
 
 This operation adds two numbers through column-addition.
 The first production retrieves the sum of the ones digits of the two numbers.
@@ -307,7 +312,7 @@ If the carry flag is set, add one to the sum.
 Again check for remainder and set a carry flag if necessary.
 Then the same repeats for the hundreds digits.
 
-\subsection*{Multiplication Operation}
+\subsubsection*{Multiplication Operation}
 
 This operation multiplies two numbers through repeated addition.
 Multiple productions handle cases in which one of the arguments is one or zero and directly set the answer accordingly.
@@ -318,20 +323,20 @@ If the counter is equal to argument 1, the operation is finished.
 If the retrieval of the sum fails, save arguments and counter in different slots and change the current operation to addition, as well as the next operation to multiplication.
 When the current operation is multiplication again and there are values in the saved argument slots, restore arguments and continue.
 
-\subsection*{Subtraction Operation}
+\subsubsection*{Subtraction Operation}
 
 The subtraction algorithm uses the austrian method, by checking for each digit if the subtrahend is greater than the minuend.
 If not, it can safely subtract the two digits and move to the next one.
 If yes, the subtraction will be done after increasing the minuend by 10.
 Additionally a carry variable will be set, which increases the subtrahend by 1 on the next digit.
 
-\subsection*{Motor System}
+\subsubsection*{Motor System}
 
 The motor module is used to input the answers and to press continue.
 When the current operation is to type the answer, the first production requests the tens digit to be pressed on the keyboard.
 When the action is finished, the ones digit and spacebar to continue are requested to be pressed in turn.
 
-\subsection*{Visual System}
+\subsubsection*{Visual System}
 
 The visual module is used for various operations to find the current task or to replace variables in a task with the values shown on the screen.
 The screen is organized in columns with headers, so the visual module first searches for the correct column by keyword.
@@ -343,7 +348,7 @@ To find a variable value by index, the search travels down the column while coun
 To find the max/min value of a variable, the search travels down all values in the column, checks for each one if it is greater/less than the currently saved value and replaces it if necessary.
 Once all values are checked, the search is finished.
 
-\subsection*{Utility Operations}
+\subsubsection*{Utility Operations}
 
 Several productions dictate in what order operations are executed.
 When the operation slots are empty, the visual search for the next unanswered task is started.
-- 
cgit v1.2.3

