Upload ASyMOB_Generation.py

ASyMOB_Generation.py

@@ -0,0 +1,348 @@
+import csv
+import json
+import sympy as sp
+import re
+import random
+import itertools
+
+# Load CSV file containing seed questions and maximal symbolic perturbations. 
+csv_file_path = 'Seed_and_Max_Symbolic_Perturbations.csv'
+
+with open(csv_file_path, 'r', encoding='utf-8') as cf:
+    data = list(csv.DictReader(cf))  # Read CSV into list of dicts
+cur_data_len = len(data)
+print("Length of initial data: ", cur_data_len)  # Print initial dataset size
+
+# Define symbolic variables that appear in the symbolic perturbations - and will be replaced by various expressions during variant generation.
+x, A, B, F, G, H, N = sp.symbols('x A B F G H N', real=True)
+Q = sp.symbols('Q', real=True, positive=True)
+
+
+# Define symbolic perturbation characters and their corresponding sympy symbols
+symnoise_char_list = ['A', 'B', 'F', 'G', 'H']
+symnoise_sym_list = [A, B, F, G, H]
+local_sym_dict = {'x': x, 'A': A, 'B': B, 'F': F, 'G': G, 'H': H, 'N': N, 'Q': Q}
+
+# These sources contain explicit hypergeometric functions, which are marked by 'F' - so 'F' is not treated as a symbolic perturbation character. 
+# The hg_ variables below represent this special treatment.
+hypergeomatric_question_sources = ["ASyMOB\nHypergeometrics\nQ1", "ASyMOB\nHypergeometrics\nQ2", "ASyMOB\nHypergeometrics\nQ3", "ASyMOB\nHypergeometrics\nQ4"]
+hg_symnoise_char_list = ['A', 'B', 'G', 'H']
+hg_symnoise_sym_list = [A, B, G, H]
+hg_local_sym_dict = {'x': x, 'A': A, 'B': B, 'G': G, 'H': H, 'N': N, 'Q': Q}
+
+
+# List of easy equivalent forms (should simplify to 1)
+equivalent_forms_easy = [
+    sp.sin(-Q*x)**2 + sp.cos(Q*x)**2,
+    -sp.sinh(Q*x)**2 + sp.cosh(Q*x)**2,
+    (sp.log(x) * sp.log(Q,x))/sp.log(Q),
+    Q * sp.Sum( x / (Q * 2**N) , (N, 1, sp.oo)) / x,
+    (sp.exp(sp.I * Q * x) - sp.exp(-sp.I * Q * x)) / (2 * sp.I * sp.sin(Q * x))
+]
+# List of hard equivalent forms (should simplify to 1)
+equivalent_forms_hard = [
+    (sp.tan((Q-1)*x) + sp.tan(x)) / ((1 - sp.tan((Q-1)*x) * sp.tan(x)) * sp.tan(Q*x)),
+    sp.sinh(sp.log(Q*x + sp.sqrt((Q*x)**2 + 1))) / (Q*x),
+    (sp.log(x / sp.E, Q) + sp.log(sp.E, Q))/ sp.log(x, Q),
+    Q * sp.Sum( (6 * x) / (Q * (N * sp.pi)**2) , (N, 1, sp.oo)) / x,
+    -((1 + sp.exp(4 * sp.I * Q * x)) / (1 - sp.exp(4 * sp.I * Q * x))) * (2 * sp.tan(Q*x) / ((1 - sp.tan(Q*x)**2)) * sp.I)
+]
+
+# Test that all equivalent forms simplify to 1 and are numerically close to 1.
+# Note that some expressions above do not simplify to 1 by sp.simplify - due to the CAS's limitations - but are evaluated correctly to 1 numerically.
+# We still print the warning to raise user awareness.
+equivalence_test_x = -2.5
+equivalence_test_Q = 0.5
+equivalence_test_margin = 1e-4
+for form in (equivalent_forms_easy + equivalent_forms_hard):
+    # Check if the form is equivalent to 1
+    if sp.simplify(form) != 1 or (abs(form.subs(Q, equivalence_test_Q).subs(x, equivalence_test_x).evalf() - 1) > equivalence_test_margin):
+        print(f"Form {form} is not equivalent to 1")
+        print(f"{form} is simplified to {sp.simplify(form)}")
+        print("Form is numerically evaluated to: ", form.subs(Q, equivalence_test_Q).subs(x, equivalence_test_x).evalf())
+    
+# LaTeX representations of the easy and hard equivalent forms
+eq_forms_latex_easy = [
+ r'\sin^{2}{\left(- Q x \right)} + \cos^{2}{\left(Q x \right)}',
+ r'- \sinh^{2}{\left(Q x \right)} + \cosh^{2}{\left(Q x \right)}',
+ r'\frac{\ln(x) \cdot \log_{x}(Q)}{\ln(Q)}',
+ r'\frac{Q \sum_{N=1}^{\infty} \frac{2^{- N} x}{Q}}{x}',
+ r'- \frac{i \left(e^{i Q x} - e^{- i Q x}\right)}{2 \sin{\left(Q x \right)}}']
+eq_forms_latex_hard = [
+ r'\frac{\tan{\left(x \right)} + \tan{\left(x \left(Q - 1\right) \right)}}{\left(- \tan{\left(x \right)} \tan{\left(x \left(Q - 1\right) \right)} + 1\right) \tan{\left(Q x \right)}}',
+ r'\frac{\sinh{\left(\log{\left(Q x + \sqrt{Q^{2} x^{2} + 1} \right)} \right)}}{Q x}',
+ r'\frac{\log_Q\left(\frac{x}{e}\right) + \log_Q(e)}{\log_Q(x)}',
+ r'\frac{Q \sum_{N=1}^{\infty} \frac{6 x}{\pi^{2} N^{2} Q}}{x}',
+ r'- \frac{2 i \left(e^{4 i Q x} + 1\right) \tan{\left(Q x \right)}}{\left(1 - e^{4 i Q x}\right) \left(1 - \tan^{2}{\left(Q x \right)}\right)}']
+
+def replace_in_dollars(s, old, new):
+    # Replace 'old' with 'new' inside all $...$ math substrings in s
+    def repl(match):
+        return match.group(0).replace(old, new)
+    return re.sub(r'\$(.*?)\$', repl, s)
+
+def char_in_dollars(s, char):
+    """Return True if char appears inside any $...$ substring in s."""
+    matches = re.findall(r'\$(.*?)\$', s)
+    return any(char in match for match in matches)
+
+def check_for_problematic_symbols(sp_ans):
+    """Check for problematic symbols in sp_ans, but allow infinities if they are only used as summation or integration limits."""
+    # Check for NaN or zoo anywhere
+    if sp_ans.has(sp.nan) or sp_ans.has(sp.zoo):
+        return True
+    # Check for oo or -oo not as summation/integration limits
+    def has_bad_infinity(expr):
+        # If it's a Sum or Integral, skip limits
+        if isinstance(expr, (sp.Sum, sp.Integral)):
+            # expr.limits is a tuple of tuples: (symbol, lower, upper)
+            # Only check the function part, not the limits
+            return has_bad_infinity(expr.function)
+        # If it's an infinity itself, it's problematic
+        if expr == sp.oo or expr == -sp.oo:
+            return True
+        # Recursively check args
+        return any(has_bad_infinity(arg) for arg in getattr(expr, 'args', []))
+    return has_bad_infinity(sp_ans)
+
+# Generate symbolic and numeric variants for each item in the dataset
+def generate_variants(items, symnoise_chars, symnoise_syms, sym_dict, cur_ind):
+    next_ind = cur_ind
+    new_items = []
+    for item in items:
+        latex_chall = item.get("Challenge")
+        sp_sym_ans = sp.sympify(item.get("Answer in Sympy"), locals = sym_dict)
+        source = item.get("Source")
+        chars_in_latex = []
+        syms_in_latex = []
+        # Find which symbolic perturbation characters are present in the LaTeX challenge
+        for i in range(len(symnoise_chars)):
+            if char_in_dollars(latex_chall, symnoise_chars[i]):
+                chars_in_latex.append(symnoise_chars[i])
+                syms_in_latex.append(symnoise_syms[i])
+        if len(chars_in_latex) == 0:
+            print("No symbolic parameters found inside math expressions in source: ",source)
+
+        item['Variation'] = f"Symbolic-{len(chars_in_latex)}"
+            
+        # Replace all symbols in symnoise_sym_list by 1 for equivalence perturbation answers.
+        sp_sym_ans_ones = sp_sym_ans.subs(dict(zip(symnoise_syms, [1]*len(symnoise_syms))))
+        # Check for problematic symbols in sp_sym_ans_ones
+        if check_for_problematic_symbols(sp_sym_ans_ones):
+            print(f"Warning: sp_sym_ans_ones for {item} contains problematic symbol(s): {sp_sym_ans_ones}")
+
+        # Generate all permutations of easy/hard equivalent forms for all symbolic chars
+        ordered_sets = list(itertools.permutations(range(len(eq_forms_latex_easy)), len(chars_in_latex)))
+        for order in ordered_sets:
+            # Substitute easy forms
+            latex_chall_copy = latex_chall
+            for i in range(len(chars_in_latex)):
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], r' \left(' + eq_forms_latex_easy[order[i]].replace('Q', chars_in_latex[i]) + r'\right) ' )
+            next_ind += 1
+            new_items.append({
+                    "Index": str(next_ind),
+                    "Challenge": latex_chall_copy,
+                    "Answer in Sympy": str(sp_sym_ans_ones),
+                    "Answer in Latex": "",
+                    "Variation": "Equivalence-All-Easy",
+                    "Source": source
+                })
+            # Substitute hard forms
+            latex_chall_copy = latex_chall
+            for i in range(len(chars_in_latex)):
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], r' \left(' + eq_forms_latex_hard[order[i]].replace('Q', chars_in_latex[i]) + r'\right) ' )
+            next_ind += 1
+            new_items.append({
+                    "Index": str(next_ind),
+                    "Challenge": latex_chall_copy,
+                    "Answer in Sympy": str(sp_sym_ans_ones),
+                    "Answer in Latex": "",
+                    "Variation": "Equivalence-All-Hard",
+                    "Source": source
+                })
+
+        # Generate single-symbolic substitutions (easy/hard) and numeric perturbation variants
+        for i in range(len(chars_in_latex)):
+            chars_left_in_latex = chars_in_latex.copy()
+            chars_left_in_latex.pop(i)
+            for j in range(len(eq_forms_latex_easy)):
+                # Substitute one easy form
+                latex_chall_copy = latex_chall
+                replace_form = r' \left(' + eq_forms_latex_easy[j].replace('Q', chars_in_latex[i]) + r'\right) '
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], replace_form )
+                for ch in chars_left_in_latex:
+                    latex_chall_copy = replace_in_dollars(latex_chall_copy, ch, '')
+                next_ind += 1
+                new_items.append({
+                        "Index": str(next_ind),
+                        "Challenge": latex_chall_copy,
+                        "Answer in Sympy": str(sp_sym_ans_ones),
+                        "Answer in Latex": "",
+                        "Variation": "Equivalence-One-Easy",
+                        "Source": source
+                    })
+                # Substitute one hard form
+                latex_chall_copy = latex_chall
+                replace_form = r' \left(' + eq_forms_latex_hard[j].replace('Q', chars_in_latex[i]) + r'\right) '
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], replace_form)
+                for ch in chars_left_in_latex:
+                    latex_chall_copy = replace_in_dollars(latex_chall_copy, ch, '')
+                next_ind += 1
+                new_items.append({
+                        "Index": str(next_ind),
+                        "Challenge": latex_chall_copy,
+                        "Answer in Sympy": str(sp_sym_ans_ones),
+                        "Answer in Latex": "",
+                        "Variation": "Equivalence-One-Hard",
+                        "Source": source
+                    })
+                
+            # Numeric perturbation: replace one symbol with a random integer of increasing digit length
+            for noise_digits in range(1, 11):
+                latex_chall_copy = latex_chall
+                sp_sym_ans_copy = sp_sym_ans
+                nn1 = random.randint(10**(noise_digits-1), 10**noise_digits - 1)
+                sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn1), evaluate=False)
+                while check_for_problematic_symbols(sp_sym_ans_copy):
+                    print(f"Warning: Numeric-One noise for {item} contains problems: {sp_sym_ans_copy}. Retrying")
+                    nn1 = random.randint(10**(noise_digits-1), 10**noise_digits - 1)
+                    sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn1), evaluate=False)
+                replace_form = r' \left(' + str(nn1) + r'\right) '
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], replace_form)
+                for ch in chars_left_in_latex:
+                    latex_chall_copy = replace_in_dollars(latex_chall_copy, ch, '')
+                for sym in syms_in_latex:
+                    sp_sym_ans_copy = sp_sym_ans_copy.subs(sym, 1)
+                latex_chall_copy = re.sub(r'Assume.*?\.', '', latex_chall_copy)
+                next_ind += 1
+                new_items.append({
+                    "Index": str(next_ind),
+                    "Challenge": latex_chall_copy,
+                    "Answer in Sympy": str(sp_sym_ans_copy),
+                    "Answer in Latex": "",
+                    "Variation": f"Numeric-One-{noise_digits}",
+                    "Source": source
+                })
+
+            
+        # Numeric perturbation: replace all symbols with random integers of increasing digit length
+        for noise_digits in range(1, 11):
+            latex_chall_copy = latex_chall
+            sp_sym_ans_copy = sp_sym_ans
+            nn_lst = [random.randint(10**(noise_digits-1), 10**noise_digits - 1) for _ in range(len(chars_in_latex))]
+            for i in range(len(chars_in_latex)):
+                sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn_lst[i]), evaluate=False)
+            while check_for_problematic_symbols(sp_sym_ans_copy):
+                print(f"Warning: Numeric-All noise for {item} contains problems: {sp_sym_ans_copy}. Retrying")
+                nn_lst = [random.randint(10**(noise_digits-1), 10**noise_digits - 1) for _ in range(len(chars_in_latex))]
+                for i in range(len(chars_in_latex)):
+                    sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn_lst[i]), evaluate=False)
+            for i in range(len(chars_in_latex)):
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], r' \left(' + str(nn_lst[i]) + r'\right) ' )
+
+            # Remove "Assume ... ." clause from latex_chall if it exists
+            latex_chall_copy = re.sub(r'Assume.*?\.', '', latex_chall_copy)
+
+            # Add new item with rolling index
+            next_ind += 1
+            new_items.append({
+                "Index": str(next_ind),
+                "Challenge": latex_chall_copy,
+                "Answer in Sympy": str(sp_sym_ans_copy),
+                "Answer in Latex": "",
+                "Variation": f"Numeric-All-{noise_digits}",
+                "Source": source
+            })
+            
+        # Generate variants with some symbols replaced by 1 (partial symbolic)
+        for i in range(1, len(chars_in_latex)):
+            oned_indexes = list(itertools.combinations(range(len(chars_in_latex)), i))
+            for oned_set in oned_indexes:
+                latex_chall_copy = latex_chall
+                sp_sym_ans_copy = sp_sym_ans
+                for ind in oned_set:
+                    latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[ind], '')
+                    sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[ind], 1)
+                next_ind += 1
+                new_items.append({
+                    "Index": str(next_ind),
+                    "Challenge": latex_chall_copy,
+                    "Answer in Sympy": str(sp_sym_ans_copy),
+                    "Answer in Latex": "",
+                    "Variation": f"Symbolic-{len(chars_in_latex) - i}",
+                    "Source": source
+                })
+    # Add new_items to data before writing output
+    data.extend(new_items)
+
+# Generate 'Numeric-All-2-S' variants - the 'Variance' subset
+def generate_NA2S(items, symnoise_chars, symnoise_syms, sym_dict, cur_ind, noise_digits, reps_num):
+    next_ind = cur_ind
+    new_items = []
+
+    for item in items:
+        latex_chall = item.get("Challenge")
+        sp_sym_ans = sp.sympify(item.get("Answer in Sympy"), locals = sym_dict)
+        source = item.get("Source")
+        chars_in_latex = []
+        syms_in_latex = []
+        # Find which symbolic noise characters are present in the LaTeX challenge
+        for i in range(len(symnoise_chars)):
+            if char_in_dollars(latex_chall, symnoise_chars[i]):
+                chars_in_latex.append(symnoise_chars[i])
+                syms_in_latex.append(symnoise_syms[i])
+        if len(chars_in_latex) == 0:
+            print("No symbolic parameters found inside math expressions in source: ",source)
+        
+        for _ in range(reps_num):
+            latex_chall_copy = latex_chall
+            sp_sym_ans_copy = sp_sym_ans
+            # Generate random integer values for all symbolic chars
+            nn_lst = [random.randint(10**(noise_digits-1), 10**(noise_digits) - 1) for _ in range(len(chars_in_latex))]
+            for i in range(len(chars_in_latex)):
+                sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn_lst[i]), evaluate=False)
+
+            while check_for_problematic_symbols(sp_sym_ans_copy):
+                print(f"Warning: Numeric-All noise for {item} contains problems: {sp_sym_ans_copy}. Retrying")
+                nn_lst = [random.randint(10**(noise_digits-1), 10**noise_digits - 1) for _ in range(len(chars_in_latex))]
+                for i in range(len(chars_in_latex)):
+                    sp_sym_ans_copy = sp_sym_ans_copy.subs(syms_in_latex[i], sp.UnevaluatedExpr(nn_lst[i]), evaluate=False)
+
+            for i in range(len(chars_in_latex)):
+                latex_chall_copy = replace_in_dollars(latex_chall_copy, chars_in_latex[i], r' \left(' + str(nn_lst[i]) + r'\right) ' )
+                
+            # Remove "Assume ... ." clause from latex_chall if it exists
+            latex_chall_copy = re.sub(r'Assume.*?\.', '', latex_chall_copy)
+            next_ind += 1
+            new_items.append({
+                "Index": str(next_ind),
+                "Challenge": latex_chall_copy,
+                "Answer in Sympy": str(sp_sym_ans_copy),
+                "Answer in Latex": "",
+                "Variation": f"Numeric-All-{noise_digits}-S",
+                "Source": source
+            })
+    # Add new_items to data before writing output
+    data.extend(new_items)
+
+
+# Split items into regular and hypergeometric symbolic questions
+sym_var_items = [item for item in data if (item.get('Variation', '').strip() == 'Symbolic' and item.get('Source') not in hypergeomatric_question_sources)]
+hypergeometric_sym_var_items = [item for item in data if (item.get('Variation', '').strip() == 'Symbolic' and item.get('Source') in hypergeomatric_question_sources)]
+
+# Generate all variants for regular and hypergeometric items
+generate_variants(sym_var_items, symnoise_char_list, symnoise_sym_list, local_sym_dict, cur_data_len)
+cur_data_len = len(data)
+generate_variants(hypergeometric_sym_var_items, hg_symnoise_char_list, hg_symnoise_sym_list, hg_local_sym_dict, cur_data_len)
+cur_data_len = len(data)
+generate_NA2S(sym_var_items, symnoise_char_list, symnoise_sym_list, local_sym_dict, cur_data_len, 2, 50)
+cur_data_len = len(data)
+generate_NA2S(hypergeometric_sym_var_items, hg_symnoise_char_list, hg_symnoise_sym_list, hg_local_sym_dict, cur_data_len, 2, 50)
+cur_data_len = len(data)
+print("Final size of the ASyMOB dataset is: " ,cur_data_len) 
+
+# Write the full dataset to a JSON file
+output_json_path = 'Full_ASyMOB_Dataset.json'
+with open(output_json_path, 'w', encoding='utf-8') as jf:
+    json.dump(data, jf, ensure_ascii=False, indent=2)
+