Duplicate from lemonteaa/algorithmic-reasoning-seed

Co-authored-by: Tom <[email protected]>

.gitattributes

@@ -0,0 +1,54 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

Algorithm_Training.md

@@ -0,0 +1,282 @@
+# Question 1: Loop invariant
+
+Given the code below:
+
+```python
+mymax = 0
+mymax_index = None
+for i, n in enumerate(mylist):
+    if n > mymax:
+        mymax = n
+        mymax_index = i
+```
+
+Uses loop invariant to prove that it computes the largest value in the list `mylist`, where mymax is the max value and mymax_index is the index in `mylist` where this maximum is attained. (Assume that all values in `mylist` is nonnegative and that `mylist` is non-empty)
+
+--
+
+*Thought:* Loop invariant is a technique to formally prove program correctness. It is a property of the program (e.g. predicate of its state as captured by the value of various variables) that remains true before and after/are preserved by each iteration. Once a loop invariant is discovered, we can often finish a proof of correctness by applying Mathematical induction to the predicate to prove the invariant - then after the whole loop ends the program state satisfies that predicate at the terminal value of the loop variable.
+
+--
+
+*Proof:*
+
+Let $P(i)$ be the assertion that `mymax` is the maximum value in the sub-array `mylist[:i+1]` and that `mymax_index` is the index where such maximum is achieved.
+
+Claim: At the end of the iteration at a particular value of i, `P(i)` is true.
+
+We'll show this by induction.
+
+Base case: `P(0)` is true after the first iteration because the list is non-empty, and `n == mylist[0]` is necessarily greater than or equal to 0 (initial value of `mymax`) from the assumption, so it will be updated correctly.
+
+Induction case: Suppose `P(i)` is true at the end of iteration i. Then after the next iteration with i+1 ends `P(i+1)` is true because maximum of the sub-array `mylist[:i+2]` is the "maximum of maximum" - take the maximum of the sub-array `mylist[:i+1]` (which by induction hypothesis is equal to `mymax` at beginning of this iteration) and the value of `mylist[i+1]` (aka n), and then max. them together. More formally, `max(mylist[:i+2]) == max(mylist[:i+1] + mylist[i+1]) == max(max(mylist[:i+1]), mylist[i+1])`.
+
+The correctness of the program as you stated follows from the claim simply by noticing that the statements we wish to prove coincide with `P(len(mylist)-1)`, which is true after the last iteration of the loop ends.
+
+# Question 2: Linear merge
+
+Show me the code in python to merge two sorted list into a sorted list in linear time.
+
+--
+
+*Thought:* This is a classic algorithm problem. The linear time constraint implies that there should be a very nice method as just reading the lists (which is information-theoretically necessary) already takes linear time. A naive method is to concatenate the list, then apply a O( n log n ) comparison sort, but it is too slow. We can improve by observing that the input itself satisfies some assumption/is nicely structured - namely that they are already sorted, and we should exploit that. Idea: How about try the "minimum of combined structure is minimum of minimum" idea? An example is the O(1) `find-min` in heap.
+
+Let's try to develop the idea. We may say model it by recursion. Remembering that more advanced application of recursion to solve problem may involve trying to design our own state space to pass around in the recursion call, we may arrive at using the `reduce` pattern to build the final merged and sorted list by "extracting" the minimum of the combined list, then the minimum of the combined list with the first element removed, and so on:
+
+```python
+def merge_sorted(list1, list2):
+    # Handle degenerate/terminal case
+    if not list1:
+        return list2
+    elif not list2:
+        return list1
+    else:
+        # min of min
+        if list1[0] < list2[0]:
+            return list1[0] + merge_sorted(list1[1:], list2)
+        else
+            return list2[0] + merge_sorted(list1, list2[1:])
+```
+
+Once this is done, we may present a solution in imperative style simply by rewriting the above/unrolling it into loop/iteration:
+
+```python
+def merge_sorted(list1, list2):
+    merged = []
+    i = 0
+    j = 0
+    while i < len(list1) and j < len(list2):
+        # Head of list comparison
+        if list1[i] < list2[j]:
+            merged.append(list1[i])
+            i += 1
+        else:
+            merged.append(list2[j])
+            j += 1
+    # Flush remainder of the list with leftovers
+    while i < len(list1):
+        merged.append(list1[i])
+        i += 1
+    while j < len(list2):
+        merged.append(list2[j])
+        j += 1
+    return merged
+```
+
+# Question 3: Reverse list (Array)
+
+Show me the code to reverse an ArrayList in Java without using libary functions.
+
+--
+
+*Thought:* This is an introductory programming exercise. A naive approach is to consruct a new list satisfying the requirement by copying from the original, but the question seems to imply that it want a mutative, or in-place answer. Generally speaking, we should be careful to avoid overwriting/state/information loss. We may do so by analyzing the data dependencies. Let the original list be `mylist` and the reversed list be `mylist_r`. Then for all `0 <= i < n`, we have `mylist[i] == mylist_r[n-1-i]`. 
+
+# Question 4: Index notation reasoning (0)
+
+Suppose `x` is a list of length `n`. What is the last element of `x`? Hence show me code to loop through each element of the list.
+
+--
+
+The last element of `x` is `x[n-1]`. This is a known feature of zero-based indexing and can be reasoned as follows: Suppose instead we have one-based indexing, that is, elements start from index 1. In that case the number of element is obviously the index of the last element due to counting: `x[1], x[2], ... , x[n]` contains n elements. However, for zero-based indexing there is an "extra" element at `x[0]`, hence a list whose last element is `x[n]` will have n+1 element. Therefore, to have n element, the index of last element should be subtracted by one.
+
+In view of the answer above, one way to loop through the list is:
+
+```
+for (int i = 0; i < n; i++) {
+    //Do something with x[i]
+}
+```
+
+This works because when `i == n-1`, the condition `i < n` is still satisfied, so we will undergo one final iteration for the last element of `x`. But after that, `i++` is executed leading to `i == n`, the condition is violated, so the loop exits as intended.
+
+Notice that since i and n are both integers, `i < n` can be replaced with `i <= n-1`. However humans generally find the version presented above more natural as the numbers themselves are not changed. This pattern also lead to adopting a convention of the semi-open interval: closed on the left, open on the right, so that something like `range(a,b)` in python refers to $[a, b)$, or inclusive of `a` but exclusive of `b`.
+
+# Question 5: Index notation reasoning (1)
+
+Suppose `b` is a reversed list of `a` and both list have length `n`. Formally state a property of the two lists in relation to each other. Show the details of your work while working with index notations.
+
+--
+
+*Thought:* Let's try to work out some initial cases to see if there is a pattern. Since `b` is a reversed list, the last element of `b` is the first element of `a`, formally: `b[n-1] == a[0]`. Notice the -1 is due to zero-based indexing. In a similar way, the second-to-last element of `b` is the second element of `a`, or `b[n-2] == a[1]`. The indices are obtained by adding one to the index of `a`, while subtracting one from the index of `b`. As this is a linear pattern, it suggests that the index expression should be a linear function of `i`, and the coefficient should be +1 for `a` (incrementing) and -1 for `b` (decrementing). Indeed we can see that `b[n-1-i] == a[i]` is the right answer: its general pattern is a reflection which is what a reversal mean, while the edge cases (`i == 0`, `i == 1`, `i == n-1`) are all corrects by substituting and then doing an explicit check.
+
+
+
+# Question 6: Reverse list (Linked list)
+
+Show me the code to reverse a LinkedList in Java without using library functions.
+
+--
+
+*Thought:* This is an introductory programming exercise. Suppose we go for an answer using imperative style and mutate in-place. We may visualize the process as a surgery as we walk over the list from left to right, moving the next pointer to point back at the previous element as we move forward. As is common in imperative paradigm, we must be careful of state loss problem, especially as we must not loss access to both the remaining part of the list, and the portion of the list we have already walked over. We may achieve this by maintaining backup/extra pointers to let us retain access.
+
+
+# Question 7: Reverse list (recursion)
+
+Show me the code to reverse a list in functional style.
+
+--
+
+
+# Question 8: Higher order function
+
+Show me the code in functional style to get a list of the square of all numbers greater than 10 in another list.
+
+--
+
+
+# Question 9: Theory of functional style
+
+Convert the following code that used recursion into one using higher order function instead:
+
+--
+
+# Question 10: Mergesort proof
+
+Give me a proof of correctness for mergesort.
+
+--
+
+
+# Question 11: Bubblesort
+
+Explain the bubblesort algortihm to me, and give a proof of correctness. Then analyze its runtime complexity.
+
+--
+
+
+# Question 12: Bit-manipulation tricks (1)
+
+Write a C macro to count the number of ones in the bits of an integer using a single C expression.
+
+--
+
+
+# Question 13: Bit-manipulation tricks (2)
+
+Write a C macro to compute the logarithm of an integer (rounded to integer) using a single C expression.
+
+--
+
+# Question 14: Amortized analysis
+
+Use the potential method to prove that a sequence of insertion operation to a dynamic array/list has O(1) amortized runtime.
+
+--
+
+
+# Question 15: Index notation reasoning (2)
+
+A virtual view into an array is a remapping of index to give the illusion of having a separate array when in fact both share the same storage. As example, suppose there is a list `under` of length `n`. We may then say have a virtual array `virtual` from `i` (inclusive) to `j` (exclusive). What this means is that the first element of `virtual` is `under[i]`, the second element is `under[i+1]`, etc, all the way to the last element `under[j-1]` (due to exclusive). Given this info, give me an expression relating the index of `virtual` to `under` and show your work. Also give concrete example of this concept implemented in programming language.
+
+--
+
+# Question 16: Index notation reasoning (3)
+
+Consider the slice functionality in python to get a virtual view into a list/array. Suppose we are now in a pseudocode language, show me the code to expand this function to enable wrap-around - that is, we may begin at some element, go to the last element, then continue back at the first element. Ensure that your code handle all edge cases.
+
+--
+
+# Question 17: Index notation reasoning (4)
+
+Suppose there is a two-dimensional array `A[i][j]` representing a matrix. Suppose this is an upper triangular matrix. Show me the code to iterate through each element.
+
+--
+
+
+# Question 18: Indexing locality
+
+In C, expand `A[i][j]` into low level pointer code to access the correct memory address. Explain the implication it has.
+
+--
+
+
+
+# Question 19: Index notation reasoning (5)
+
+Rewrite the following code exchanging the inner and outer loop:
+
+--
+
+
+# Question 20: Index notation reasoning (6)
+
+Recall that a (balanced) band matrix is a matrix whose only non-zero entries are on diagonals within a small distance of the main or central diagonal. Formally, for a `n` by `n` square matrix `A[i][j]`, the entries are non-zero only if $| i - j | <= k$. Given these info, show me the code to iterate through all non-zero elements of `A`.
+
+--
+
+# Question 21: Tensor?
+
+
+# Question 22: Tail recursion
+
+Given the following implementation of the higher order function `filter`:
+
+Rewrite the code so that it is tail recursive.
+
+--
+
+# Question 23: Tree recursion (easy)
+
+Show me the code to compute the height of a tree using recursion.
+
+--
+
+
+# Question 24: Tree recursion
+
+Given a tree whose leaf nodes contain a numeric value, show me the code to compute the weighted sum of all these value, where the weight is the depth of that leaf node.
+
+--
+
+# Question 25: Linked list
+
+Show me the code to insert a circular doubly linked list into another linked list in O(1) time.
+
+--
+
+# Question 26: String Join
+
+Show me the code in Java to join a list of string with a separator string given. Reimplement directly using primitives instead of using library function. Signature is `public String myjoin(List<String> strs, String sep)`.
+
+Example: TODO (Show normal case, 1 string, and 0 string)
+
+--
+
+# Question 27: Set using Hashmap
+
+Show me the code to reimplement set and basic operations ourselves, including "intersection", "union", and "subtract", using Hashmap.
+
+--
+
+# Question 28: Remove duplicates inplace
+
+Show me the code to remove duplicate items in a list in-place - that is you should modify the input list directly.
+
+
+
+
+
+
+
+
+

README.md

@@ -0,0 +1,124 @@
+---
+license: mit
+task_categories:
+- text-generation
+- question-answering
+language:
+- en
+tags:
+- code
+size_categories:
+- n<1K
+---
+# Dataset Card for Algorithmic Reasoning (seed)
+
+**Note: This dataset is WIP and most question's answer section is empty or incomplete! See also "Other Known Limitations" section**
+
+**Warning: If you somehow do use this dataset, remember to NOT do any eval after training on the questions in this dataset!**
+
+## Dataset Description
+
+- **Homepage:** 
+- **Repository:** 
+- **Paper:** 
+- **Leaderboard:** 
+- **Point of Contact:** [email protected] or https://github.com/lemonteaa
+
+### Dataset Summary
+
+Dataset to help LLM learn how to reason about code, especially on algorithmic tasks, by seeing human demostration.
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+[More Information Needed]
+
+## Dataset Structure
+
+### Data Instances
+
+[More Information Needed]
+
+### Data Fields
+
+- Question title
+- Question
+- Thought - Internal thought process that reason step by step/in an organized manner
+- Answer presented to user (proof or code) - with explanation if necessary
+
+### Data Splits
+
+No split as of now - all are in the training section.
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+Questions are those I personally remember in my career, selected based on:
+
+- interesting
+- involving CS, math, or similar knowledge
+- Target specific known weaknesses of existing open source/source available LLM (eg index notation handling)
+- pratical/likely to appear in production work settings
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+#### Annotation process
+
+Manually created by me entirely, writing in a level of details exceeeding what usually appears on the internet (bootcamp/FANNG interview prep/leetcode style training website etc) to help AI/LLM access knowledge that may be too obvious to human to write down.
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+None as they are general, objective knowledge.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+Although it is doubtful this dataset can actually work, in the event it does this may result in enhancing coding capability of LLM (which is intended), but which may create downstream effect simply due to LLM capability enhancement.
+
+### Discussion of Biases
+
+As questions are selected partly based on my taste, areas in CS that I am not interested in may be underrepresented.
+
+### Other Known Limitations
+
+- While I try to cover various mainstream programming language, each problem target only one specific language.
+- It is currently in free-style markdown file. Maybe could make a script to convert to more structured format.
+- Questions are asked in a conversational tone instead of leetcode style with strict I/O specification, hence may be more suitable for human eval than automated eval (eg extract and run code output in sandbox against test case automatically).
+- As the dataset is completely manually created by a single human, the dataset size is extremely small.
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+MIT
+
+### Citation Information
+
+[More Information Needed]
+
+### Contributions
+
+[More Information Needed]

algorithmic-reasoning-seed.py

@@ -0,0 +1,77 @@
+import datasets
+from enum import Enum
+
+class ParseState(Enum):
+    QUESTION = 1
+    THOUGHT = 2
+    ANSWER = 3
+
+logger = datasets.logging.get_logger(__name__)
+
+_DESCRIPTION = "TODO"
+
+_URLS = {"train":"Algorithm_Training.md"}
+
+class AlgorithmicReasoningSeed(datasets.GeneratorBasedBuilder):
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "title": datasets.Value("string"),
+                    "question": datasets.Value("string"),
+                    "thought": datasets.Value("string"),
+                    "answer": datasets.Value("string")
+                }
+            ),
+            # No default supervised_keys (as we have to pass both question
+            # and context as input).
+            supervised_keys=None,
+            homepage="",
+            citation=""
+        )
+
+    def _split_generators(self, dl_manager):
+        downloaded_files = dl_manager.download_and_extract(_URLS)
+        return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": downloaded_files["train"]})
+               ]
+
+    def _generate_examples(self, filepath):
+        """This function returns the examples in the raw (text) form."""
+        logger.info("generating examples from = %s", filepath)
+        key = 0
+        with open(filepath, encoding="utf-8") as f:
+            title = ""
+            question = []
+            thought = []
+            answer = []
+            first = True
+            state = ParseState.QUESTION
+            for line in f:
+                if len(line) >= 1 and line[0] == '#':
+                    if not first:
+                        logger.info("question id=%d, title=%s", key, title)
+                        yield key, {"id":key, "title": title, "question":'\n'.join(question), "thought":'\n'.join(thought), "answer":'\n'.join(answer)}
+                    first = False
+                    key += 1
+                    title = line.split(':')[1].strip()
+                    question = []
+                    thought = []
+                    answer = []
+                    state = ParseState.QUESTION
+                    continue
+                if len(line) >= 2 and line[0:2] == '--':
+                    if state == ParseState.QUESTION:
+                        state = ParseState.THOUGHT
+                    elif state == ParseState.THOUGHT:
+                        state = ParseState.ANSWER
+                    continue
+                if state == ParseState.QUESTION:
+                    question.append(line)
+                elif state == ParseState.THOUGHT:
+                    thought.append(line)
+                else:
+                    answer.append(line)
+            yield key, {"id":key, "title": title, "question":'\n'.join(question), "thought":'\n'.join(thought), "answer":'\n'.join(answer)}
+        logger.info("finished.")