koichi12 commited on Feb 12, 2025

Commit

bb9058c

verified ·

1 Parent(s): b163abe

Add files using upload-large-folder tool

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

llm_tutorial/merged_models/en-ja-base_0.33/tokenizer_config.json +83 -0
llm_tutorial/merged_models/en-ja-base_dare-linear/README.md +46 -0
llm_tutorial/merged_models/en-ja-base_dare-linear/mergekit_config.yml +16 -0
llm_tutorial/merged_models/en-ja-base_dare/special_tokens_map.json +10 -0
llm_tutorial/merged_models/en-ja_ja-en_base_linear+instruct/special_tokens_map.json +51 -0
llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.33/README.md +43 -0
llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.33/special_tokens_map.json +51 -0
llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.5/special_tokens_map.json +51 -0
llm_tutorial/merged_models/en-ja_merged/mergekit_config.yml +9 -0
llm_tutorial/merged_models/en-ja_merged/tokenizer_config.json +83 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties01-instruct/mergekit_config.yml +12 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties01/README.md +42 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties01/model.safetensors.index.json +1 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties01/tokenizer.json +0 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties02/config.json +30 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties02/tokenizer.json +0 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties03-instruct/README.md +42 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties03/README.md +42 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties03/config.json +30 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties03/mergekit_config.yml +12 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties03/model.safetensors.index.json +1 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties04/README.md +42 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties04/mergekit_config.yml +12 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties04/model.safetensors.index.json +1 -0
llm_tutorial/merged_models4/ja-en_en-ja_ties04/special_tokens_map.json +10 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/__pycache__/test_baseclasses.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/__pycache__/test_drawing.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/test_baseclasses.py +209 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/__pycache__/pynodes.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/__pycache__/pyutils.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/abstract_nodes.py +18 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/ast.py +1906 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/cnodes.py +156 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/cutils.py +8 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/futils.py +40 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/matrix_nodes.py +71 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/pynodes.py +11 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/scipy_nodes.py +79 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/combinatorics/tests/__pycache__/__init__.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/__pycache__/delta.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/delta.py +330 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/expr_with_intlimits.py +354 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/expr_with_limits.py +603 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/products.py +610 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/summations.py +1646 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/kind.py +97 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/ntheory/tests/__pycache__/test_factor_.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/__pycache__/__init__.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/__pycache__/base_backend.cpython-311.pyc +0 -0
tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/matplotlibbackend/__init__.py +5 -0

llm_tutorial/merged_models/en-ja-base_0.33/tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,83 @@

+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<MASK|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "<PAD|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "5": {
+      "content": "<CLS|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "6": {
+      "content": "<SEP|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "7": {
+      "content": "<EOD|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<CLS|LLM-jp>",
+  "eod_token": "</s>",
+  "eos_token": "</s>",
+  "extra_ids": 0,
+  "mask_token": "<MASK|LLM-jp>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<PAD|LLM-jp>",
+  "sep_token": "<SEP|LLM-jp>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "<unk>"
+}

llm_tutorial/merged_models/en-ja-base_dare-linear/README.md ADDED Viewed

	@@ -0,0 +1,46 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# en-ja-base_dare-linear
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the linear [DARE](https://arxiv.org/abs/2311.03099) merge method using /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b as a base.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+    # No parameters necessary for base model
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+    parameters:
+      density: 0.53
+      weight: 0.3
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+    parameters:
+      density: 0.53
+      weight: 0.3
+merge_method: dare_linear
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+parameters:
+  int8_mask: true
+dtype: bfloat16
+```

llm_tutorial/merged_models/en-ja-base_dare-linear/mergekit_config.yml ADDED Viewed

	@@ -0,0 +1,16 @@

+models:
+  - model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+    # No parameters necessary for base model
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+    parameters:
+      density: 0.53
+      weight: 0.3
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+    parameters:
+      density: 0.53
+      weight: 0.3
+merge_method: dare_linear
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+parameters:
+  int8_mask: true
+dtype: bfloat16

llm_tutorial/merged_models/en-ja-base_dare/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,10 @@

+{
+    "bos_token": "<s>",
+    "cls_token": "<CLS|LLM-jp>",
+    "eod_token": "</s>",
+    "eos_token": "</s>",
+    "mask_token": "<MASK|LLM-jp>",
+    "pad_token": "<PAD|LLM-jp>",
+    "sep_token": "<SEP|LLM-jp>",
+    "unk_token": "<unk>"
+}

llm_tutorial/merged_models/en-ja_ja-en_base_linear+instruct/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,51 @@

+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<CLS|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<MASK|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<PAD|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "<SEP|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.33/README.md ADDED Viewed

	@@ -0,0 +1,43 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# en-ja_ja-en_instruct_linear_0.33
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the [linear](https://arxiv.org/abs/2203.05482) merge method.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+* /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.33
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.33
+  - model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct
+    parameters:
+      weight: 0.33
+merge_method: linear
+dtype: float16
+```

llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.33/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,51 @@

+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<CLS|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<MASK|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<PAD|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "<SEP|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

llm_tutorial/merged_models/en-ja_ja-en_instruct_linear_0.5/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,51 @@

+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<CLS|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<MASK|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<PAD|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "<SEP|LLM-jp>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

llm_tutorial/merged_models/en-ja_merged/mergekit_config.yml ADDED Viewed

	@@ -0,0 +1,9 @@

+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model/llm-jp-v3-3.7b_ja-en_actual_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+merge_method: linear
+dtype: float16

llm_tutorial/merged_models/en-ja_merged/tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,83 @@

+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<MASK|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "<PAD|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "5": {
+      "content": "<CLS|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "6": {
+      "content": "<SEP|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "7": {
+      "content": "<EOD|LLM-jp>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<CLS|LLM-jp>",
+  "eod_token": "</s>",
+  "eos_token": "</s>",
+  "extra_ids": 0,
+  "mask_token": "<MASK|LLM-jp>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<PAD|LLM-jp>",
+  "sep_token": "<SEP|LLM-jp>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "<unk>"
+}

llm_tutorial/merged_models4/ja-en_en-ja_ties01-instruct/mergekit_config.yml ADDED Viewed

	@@ -0,0 +1,12 @@

+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en-instruct_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+      density: 0.1
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja-instruct_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+      density: 0.1
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct
+merge_method: ties
+dtype: float16

llm_tutorial/merged_models4/ja-en_en-ja_ties01/README.md ADDED Viewed

	@@ -0,0 +1,42 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# ja-en_en-ja_ties01
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the [TIES](https://arxiv.org/abs/2306.01708) merge method using /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b as a base.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.1
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.1
+      weight: 0.5
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+merge_method: ties
+dtype: float16
+```

llm_tutorial/merged_models4/ja-en_en-ja_ties01/model.safetensors.index.json ADDED Viewed

	@@ -0,0 +1 @@

+ {"metadata": {"mergekit_version": "0.0.5.1", "total_size": 7565826048}, "weight_map": {"lm_head.weight": "model-00001-of-00002.safetensors", "model.embed_tokens.weight": "model-00001-of-00002.safetensors", "model.layers.0.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.0.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.1.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.10.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.10.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.10.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.11.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.11.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.11.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.12.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.12.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.12.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.13.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.13.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.13.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.14.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.14.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.14.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.15.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.15.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.15.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.16.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.16.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.16.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.17.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.17.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.17.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.18.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.18.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.18.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.19.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.19.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.19.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.2.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.20.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.20.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.20.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.21.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.21.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.21.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.22.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.22.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", "model.layers.22.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", "model.layers.23.input_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.23.mlp.down_proj.weight": "model-00001-of-00002.safetensors", "model.layers.23.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", "model.layers.23.mlp.up_proj.weight": "model-00001-of-00002.safetensors", "model.layers.23.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", "model.layers.23.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.23.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.23.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.23.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.24.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.24.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.24.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.25.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.25.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.25.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.26.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.26.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.26.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.27.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.27.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.27.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.3.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.3.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.3.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.4.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.4.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.4.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.5.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.5.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.5.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.6.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.6.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.6.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.7.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.7.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.7.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.8.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.8.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.8.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.input_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.9.mlp.down_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.mlp.up_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", "model.layers.9.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", "model.layers.9.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", "model.norm.weight": "model-00002-of-00002.safetensors"}}

llm_tutorial/merged_models4/ja-en_en-ja_ties01/tokenizer.json ADDED Viewed

The diff for this file is too large to render. See raw diff

llm_tutorial/merged_models4/ja-en_en-ja_ties02/config.json ADDED Viewed

	@@ -0,0 +1,30 @@

+{
+  "_name_or_path": "/work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b",
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 3072,
+  "initializer_range": 0.02,
+  "intermediate_size": 8192,
+  "max_position_embeddings": 4096,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 24,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 24,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "rope_theta": 10000,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.46.2",
+  "use_cache": true,
+  "vocab_size": 99584
+}

llm_tutorial/merged_models4/ja-en_en-ja_ties02/tokenizer.json ADDED Viewed

The diff for this file is too large to render. See raw diff

llm_tutorial/merged_models4/ja-en_en-ja_ties03-instruct/README.md ADDED Viewed

	@@ -0,0 +1,42 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# ja-en_en-ja_ties03-instruct
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the [TIES](https://arxiv.org/abs/2306.01708) merge method using /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct as a base.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja-instruct_3M-pairs/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en-instruct_3M-pairs/iter_0000698
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en-instruct_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+      density: 0.3
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja-instruct_3M-pairs/iter_0000698
+    parameters:
+      weight: 0.5
+      density: 0.3
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct
+merge_method: ties
+dtype: float16
+```

llm_tutorial/merged_models4/ja-en_en-ja_ties03/README.md ADDED Viewed

	@@ -0,0 +1,42 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# ja-en_en-ja_ties03
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the [TIES](https://arxiv.org/abs/2306.01708) merge method using /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b as a base.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.3
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.3
+      weight: 0.5
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+merge_method: ties
+dtype: float16
+```

llm_tutorial/merged_models4/ja-en_en-ja_ties03/config.json ADDED Viewed

	@@ -0,0 +1,30 @@

+{
+  "_name_or_path": "/work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b",
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 3072,
+  "initializer_range": 0.02,
+  "intermediate_size": 8192,
+  "max_position_embeddings": 4096,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 24,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 24,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "rope_theta": 10000,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.46.2",
+  "use_cache": true,
+  "vocab_size": 99584
+}

llm_tutorial/merged_models4/ja-en_en-ja_ties03/mergekit_config.yml ADDED Viewed

	@@ -0,0 +1,12 @@

+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.3
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.3
+      weight: 0.5
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+merge_method: ties
+dtype: float16

llm_tutorial/merged_models4/ja-en_en-ja_ties03/model.safetensors.index.json ADDED Viewed

	@@ -0,0 +1 @@

llm_tutorial/merged_models4/ja-en_en-ja_ties04/README.md ADDED Viewed

	@@ -0,0 +1,42 @@

+---
+base_model: []
+library_name: transformers
+tags:
+- mergekit
+- merge
+---
+# ja-en_en-ja_ties04
+This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).
+## Merge Details
+### Merge Method
+This model was merged using the [TIES](https://arxiv.org/abs/2306.01708) merge method using /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b as a base.
+### Models Merged
+The following models were included in the merge:
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+* /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+### Configuration
+The following YAML configuration was used to produce this model:
+```yaml
+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.4
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.4
+      weight: 0.5
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+merge_method: ties
+dtype: float16
+```

llm_tutorial/merged_models4/ja-en_en-ja_ties04/mergekit_config.yml ADDED Viewed

	@@ -0,0 +1,12 @@

+models:
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_ja-en_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.4
+      weight: 0.5
+  - model: /home/koiwa/work/llm_tutorial/llm_recipes/models/hf-model-eval/llm-jp-v3-3.7b_en-ja_3M-pairs_3.5e-5/iter_0000698
+    parameters:
+      density: 0.4
+      weight: 0.5
+base_model: /work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b
+merge_method: ties
+dtype: float16

llm_tutorial/merged_models4/ja-en_en-ja_ties04/model.safetensors.index.json ADDED Viewed

	@@ -0,0 +1 @@

llm_tutorial/merged_models4/ja-en_en-ja_ties04/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,10 @@

+{
+    "bos_token": "<s>",
+    "cls_token": "<CLS|LLM-jp>",
+    "eod_token": "</s>",
+    "eos_token": "</s>",
+    "mask_token": "<MASK|LLM-jp>",
+    "pad_token": "<PAD|LLM-jp>",
+    "sep_token": "<SEP|LLM-jp>",
+    "unk_token": "<unk>"
+}

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/__pycache__/test_baseclasses.cpython-311.pyc ADDED Viewed

Binary file (11.8 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/__pycache__/test_drawing.cpython-311.pyc ADDED Viewed

Binary file (39.1 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/categories/tests/test_baseclasses.py ADDED Viewed

	@@ -0,0 +1,209 @@

+from sympy.categories import (Object, Morphism, IdentityMorphism,
+                              NamedMorphism, CompositeMorphism,
+                              Diagram, Category)
+from sympy.categories.baseclasses import Class
+from sympy.testing.pytest import raises
+from sympy.core.containers import (Dict, Tuple)
+from sympy.sets import EmptySet
+from sympy.sets.sets import FiniteSet
+def test_morphisms():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    # Test the base morphism.
+    f = NamedMorphism(A, B, "f")
+    assert f.domain == A
+    assert f.codomain == B
+    assert f == NamedMorphism(A, B, "f")
+    # Test identities.
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    assert id_A.domain == A
+    assert id_A.codomain == A
+    assert id_A == IdentityMorphism(A)
+    assert id_A != id_B
+    # Test named morphisms.
+    g = NamedMorphism(B, C, "g")
+    assert g.name == "g"
+    assert g != f
+    assert g == NamedMorphism(B, C, "g")
+    assert g != NamedMorphism(B, C, "f")
+    # Test composite morphisms.
+    assert f == CompositeMorphism(f)
+    k = g.compose(f)
+    assert k.domain == A
+    assert k.codomain == C
+    assert k.components == Tuple(f, g)
+    assert g * f == k
+    assert CompositeMorphism(f, g) == k
+    assert CompositeMorphism(g * f) == g * f
+    # Test the associativity of composition.
+    h = NamedMorphism(C, D, "h")
+    p = h * g
+    u = h * g * f
+    assert h * k == u
+    assert p * f == u
+    assert CompositeMorphism(f, g, h) == u
+    # Test flattening.
+    u2 = u.flatten("u")
+    assert isinstance(u2, NamedMorphism)
+    assert u2.name == "u"
+    assert u2.domain == A
+    assert u2.codomain == D
+    # Test identities.
+    assert f * id_A == f
+    assert id_B * f == f
+    assert id_A * id_A == id_A
+    assert CompositeMorphism(id_A) == id_A
+    # Test bad compositions.
+    raises(ValueError, lambda: f * g)
+    raises(TypeError, lambda: f.compose(None))
+    raises(TypeError, lambda: id_A.compose(None))
+    raises(TypeError, lambda: f * None)
+    raises(TypeError, lambda: id_A * None)
+    raises(TypeError, lambda: CompositeMorphism(f, None, 1))
+    raises(ValueError, lambda: NamedMorphism(A, B, ""))
+    raises(NotImplementedError, lambda: Morphism(A, B))
+def test_diagram():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    empty = EmptySet
+    # Test the addition of identities.
+    d1 = Diagram([f])
+    assert d1.objects == FiniteSet(A, B)
+    assert d1.hom(A, B) == (FiniteSet(f), empty)
+    assert d1.hom(A, A) == (FiniteSet(id_A), empty)
+    assert d1.hom(B, B) == (FiniteSet(id_B), empty)
+    assert d1 == Diagram([id_A, f])
+    assert d1 == Diagram([f, f])
+    # Test the addition of composites.
+    d2 = Diagram([f, g])
+    homAC = d2.hom(A, C)[0]
+    assert d2.objects == FiniteSet(A, B, C)
+    assert g * f in d2.premises.keys()
+    assert homAC == FiniteSet(g * f)
+    # Test equality, inequality and hash.
+    d11 = Diagram([f])
+    assert d1 == d11
+    assert d1 != d2
+    assert hash(d1) == hash(d11)
+    d11 = Diagram({f: "unique"})
+    assert d1 != d11
+    # Make sure that (re-)adding composites (with new properties)
+    # works as expected.
+    d = Diagram([f, g], {g * f: "unique"})
+    assert d.conclusions == Dict({g * f: FiniteSet("unique")})
+    # Check the hom-sets when there are premises and conclusions.
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    d = Diagram([f, g], [g * f])
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    # Check how the properties of composite morphisms are computed.
+    d = Diagram({f: ["unique", "isomorphism"], g: "unique"})
+    assert d.premises[g * f] == FiniteSet("unique")
+    # Check that conclusion morphisms with new objects are not allowed.
+    d = Diagram([f], [g])
+    assert d.conclusions == Dict({})
+    # Test an empty diagram.
+    d = Diagram()
+    assert d.premises == Dict({})
+    assert d.conclusions == Dict({})
+    assert d.objects == empty
+    # Check a SymPy Dict object.
+    d = Diagram(Dict({f: FiniteSet("unique", "isomorphism"), g: "unique"}))
+    assert d.premises[g * f] == FiniteSet("unique")
+    # Check the addition of components of composite morphisms.
+    d = Diagram([g * f])
+    assert f in d.premises
+    assert g in d.premises
+    # Check subdiagrams.
+    d = Diagram([f, g], {g * f: "unique"})
+    d1 = Diagram([f])
+    assert d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+    d = Diagram([NamedMorphism(B, A, "f'")])
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+    d1 = Diagram([f, g], {g * f: ["unique", "something"]})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+    d = Diagram({f: "blooh"})
+    d1 = Diagram({f: "bleeh"})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+    d = Diagram([f, g], {f: "unique", g * f: "veryunique"})
+    d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+    assert d1 == Diagram([f], {f: "unique"})
+    raises(ValueError, lambda: d.subdiagram_from_objects(FiniteSet(A,
+           Object("D"))))
+    raises(ValueError, lambda: Diagram({IdentityMorphism(A): "unique"}))
+def test_category():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+    objects = d1.objects | d2.objects
+    K = Category("K", objects, commutative_diagrams=[d1, d2])
+    assert K.name == "K"
+    assert K.objects == Class(objects)
+    assert K.commutative_diagrams == FiniteSet(d1, d2)
+    raises(ValueError, lambda: Category(""))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/__pycache__/pynodes.cpython-311.pyc ADDED Viewed

Binary file (884 Bytes). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/__pycache__/pyutils.cpython-311.pyc ADDED Viewed

Binary file (1.76 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/abstract_nodes.py ADDED Viewed

	@@ -0,0 +1,18 @@

+"""This module provides containers for python objects that are valid
+printing targets but are not a subclass of SymPy's Printable.
+"""
+from sympy.core.containers import Tuple
+class List(Tuple):
+    """Represents a (frozen) (Python) list (for code printing purposes)."""
+    def __eq__(self, other):
+        if isinstance(other, list):
+            return self == List(*other)
+        else:
+            return self.args == other
+    def __hash__(self):
+        return super().__hash__()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/ast.py ADDED Viewed

	@@ -0,0 +1,1906 @@

+"""
+Types used to represent a full function/module as an Abstract Syntax Tree.
+Most types are small, and are merely used as tokens in the AST. A tree diagram
+has been included below to illustrate the relationships between the AST types.
+AST Type Tree
+-------------
+::
+  *Basic*
+       |
+       |
+   CodegenAST
+       |
+       |--->AssignmentBase
+       |             |--->Assignment
+       |             |--->AugmentedAssignment
+       |                                    |--->AddAugmentedAssignment
+       |                                    |--->SubAugmentedAssignment
+       |                                    |--->MulAugmentedAssignment
+       |                                    |--->DivAugmentedAssignment
+       |                                    |--->ModAugmentedAssignment
+       |
+       |--->CodeBlock
+       |
+       |
+       |--->Token
+                |--->Attribute
+                |--->For
+                |--->String
+                |       |--->QuotedString
+                |       |--->Comment
+                |--->Type
+                |       |--->IntBaseType
+                |       |              |--->_SizedIntType
+                |       |                               |--->SignedIntType
+                |       |                               |--->UnsignedIntType
+                |       |--->FloatBaseType
+                |                        |--->FloatType
+                |                        |--->ComplexBaseType
+                |                                           |--->ComplexType
+                |--->Node
+                |       |--->Variable
+                |       |           |---> Pointer
+                |       |--->FunctionPrototype
+                |                            |--->FunctionDefinition
+                |--->Element
+                |--->Declaration
+                |--->While
+                |--->Scope
+                |--->Stream
+                |--->Print
+                |--->FunctionCall
+                |--->BreakToken
+                |--->ContinueToken
+                |--->NoneToken
+                |--->Return
+Predefined types
+----------------
+A number of ``Type`` instances are provided in the ``sympy.codegen.ast`` module
+for convenience. Perhaps the two most common ones for code-generation (of numeric
+codes) are ``float32`` and ``float64`` (known as single and double precision respectively).
+There are also precision generic versions of Types (for which the codeprinters selects the
+underlying data type at time of printing): ``real``, ``integer``, ``complex_``, ``bool_``.
+The other ``Type`` instances defined are:
+- ``intc``: Integer type used by C's "int".
+- ``intp``: Integer type used by C's "unsigned".
+- ``int8``, ``int16``, ``int32``, ``int64``: n-bit integers.
+- ``uint8``, ``uint16``, ``uint32``, ``uint64``: n-bit unsigned integers.
+- ``float80``: known as "extended precision" on modern x86/amd64 hardware.
+- ``complex64``: Complex number represented by two ``float32`` numbers
+- ``complex128``: Complex number represented by two ``float64`` numbers
+Using the nodes
+---------------
+It is possible to construct simple algorithms using the AST nodes. Let's construct a loop applying
+Newton's method::
+    >>> from sympy import symbols, cos
+    >>> from sympy.codegen.ast import While, Assignment, aug_assign, Print, QuotedString
+    >>> t, dx, x = symbols('tol delta val')
+    >>> expr = cos(x) - x**3
+    >>> whl = While(abs(dx) > t, [
+    ...     Assignment(dx, -expr/expr.diff(x)),
+    ...     aug_assign(x, '+', dx),
+    ...     Print([x])
+    ... ])
+    >>> from sympy import pycode
+    >>> py_str = pycode(whl)
+    >>> print(py_str)
+    while (abs(delta) > tol):
+        delta = (val**3 - math.cos(val))/(-3*val**2 - math.sin(val))
+        val += delta
+        print(val)
+    >>> import math
+    >>> tol, val, delta = 1e-5, 0.5, float('inf')
+    >>> exec(py_str)
+    1.1121416371
+    0.909672693737
+    0.867263818209
+    0.865477135298
+    0.865474033111
+    >>> print('%3.1g' % (math.cos(val) - val**3))
+    -3e-11
+If we want to generate Fortran code for the same while loop we simple call ``fcode``::
+    >>> from sympy import fcode
+    >>> print(fcode(whl, standard=2003, source_format='free'))
+    do while (abs(delta) > tol)
+       delta = (val**3 - cos(val))/(-3*val**2 - sin(val))
+       val = val + delta
+       print *, val
+    end do
+There is a function constructing a loop (or a complete function) like this in
+:mod:`sympy.codegen.algorithms`.
+"""
+from __future__ import annotations
+from typing import Any
+from collections import defaultdict
+from sympy.core.relational import (Ge, Gt, Le, Lt)
+from sympy.core import Symbol, Tuple, Dummy
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr, Atom
+from sympy.core.numbers import Float, Integer, oo
+from sympy.core.sympify import _sympify, sympify, SympifyError
+from sympy.utilities.iterables import (iterable, topological_sort,
+                                       numbered_symbols, filter_symbols)
+def _mk_Tuple(args):
+    """
+    Create a SymPy Tuple object from an iterable, converting Python strings to
+    AST strings.
+    Parameters
+    ==========
+    args: iterable
+        Arguments to :class:`sympy.Tuple`.
+    Returns
+    =======
+    sympy.Tuple
+    """
+    args = [String(arg) if isinstance(arg, str) else arg for arg in args]
+    return Tuple(*args)
+class CodegenAST(Basic):
+    __slots__ = ()
+class Token(CodegenAST):
+    """ Base class for the AST types.
+    Explanation
+    ===========
+    Defining fields are set in ``_fields``. Attributes (defined in _fields)
+    are only allowed to contain instances of Basic (unless atomic, see
+    ``String``). The arguments to ``__new__()`` correspond to the attributes in
+    the order defined in ``_fields`. The ``defaults`` class attribute is a
+    dictionary mapping attribute names to their default values.
+    Subclasses should not need to override the ``__new__()`` method. They may
+    define a class or static method named ``_construct_<attr>`` for each
+    attribute to process the value passed to ``__new__()``. Attributes listed
+    in the class attribute ``not_in_args`` are not passed to :class:`~.Basic`.
+    """
+    __slots__: tuple[str, ...] = ()
+    _fields = __slots__
+    defaults: dict[str, Any] = {}
+    not_in_args: list[str] = []
+    indented_args = ['body']
+    @property
+    def is_Atom(self):
+        return len(self._fields) == 0
+    @classmethod
+    def _get_constructor(cls, attr):
+        """ Get the constructor function for an attribute by name. """
+        return getattr(cls, '_construct_%s' % attr, lambda x: x)
+    @classmethod
+    def _construct(cls, attr, arg):
+        """ Construct an attribute value from argument passed to ``__new__()``. """
+        # arg may be ``NoneToken()``, so comparison is done using == instead of ``is`` operator
+        if arg == None:
+            return cls.defaults.get(attr, none)
+        else:
+            if isinstance(arg, Dummy):  # SymPy's replace uses Dummy instances
+                return arg
+            else:
+                return cls._get_constructor(attr)(arg)
+    def __new__(cls, *args, **kwargs):
+        # Pass through existing instances when given as sole argument
+        if len(args) == 1 and not kwargs and isinstance(args[0], cls):
+            return args[0]
+        if len(args) > len(cls._fields):
+            raise ValueError("Too many arguments (%d), expected at most %d" % (len(args), len(cls._fields)))
+        attrvals = []
+        # Process positional arguments
+        for attrname, argval in zip(cls._fields, args):
+            if attrname in kwargs:
+                raise TypeError('Got multiple values for attribute %r' % attrname)
+            attrvals.append(cls._construct(attrname, argval))
+        # Process keyword arguments
+        for attrname in cls._fields[len(args):]:
+            if attrname in kwargs:
+                argval = kwargs.pop(attrname)
+            elif attrname in cls.defaults:
+                argval = cls.defaults[attrname]
+            else:
+                raise TypeError('No value for %r given and attribute has no default' % attrname)
+            attrvals.append(cls._construct(attrname, argval))
+        if kwargs:
+            raise ValueError("Unknown keyword arguments: %s" % ' '.join(kwargs))
+        # Parent constructor
+        basic_args = [
+            val for attr, val in zip(cls._fields, attrvals)
+            if attr not in cls.not_in_args
+        ]
+        obj = CodegenAST.__new__(cls, *basic_args)
+        # Set attributes
+        for attr, arg in zip(cls._fields, attrvals):
+            setattr(obj, attr, arg)
+        return obj
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        for attr in self._fields:
+            if getattr(self, attr) != getattr(other, attr):
+                return False
+        return True
+    def _hashable_content(self):
+        return tuple([getattr(self, attr) for attr in self._fields])
+    def __hash__(self):
+        return super().__hash__()
+    def _joiner(self, k, indent_level):
+        return (',\n' + ' '*indent_level) if k in self.indented_args else ', '
+    def _indented(self, printer, k, v, *args, **kwargs):
+        il = printer._context['indent_level']
+        def _print(arg):
+            if isinstance(arg, Token):
+                return printer._print(arg, *args, joiner=self._joiner(k, il), **kwargs)
+            else:
+                return printer._print(arg, *args, **kwargs)
+        if isinstance(v, Tuple):
+            joined = self._joiner(k, il).join([_print(arg) for arg in v.args])
+            if k in self.indented_args:
+                return '(\n' + ' '*il + joined + ',\n' + ' '*(il - 4) + ')'
+            else:
+                return ('({0},)' if len(v.args) == 1 else '({0})').format(joined)
+        else:
+            return _print(v)
+    def _sympyrepr(self, printer, *args, joiner=', ', **kwargs):
+        from sympy.printing.printer import printer_context
+        exclude = kwargs.get('exclude', ())
+        values = [getattr(self, k) for k in self._fields]
+        indent_level = printer._context.get('indent_level', 0)
+        arg_reprs = []
+        for i, (attr, value) in enumerate(zip(self._fields, values)):
+            if attr in exclude:
+                continue
+            # Skip attributes which have the default value
+            if attr in self.defaults and value == self.defaults[attr]:
+                continue
+            ilvl = indent_level + 4 if attr in self.indented_args else 0
+            with printer_context(printer, indent_level=ilvl):
+                indented = self._indented(printer, attr, value, *args, **kwargs)
+            arg_reprs.append(('{1}' if i == 0 else '{0}={1}').format(attr, indented.lstrip()))
+        return "{}({})".format(self.__class__.__name__, joiner.join(arg_reprs))
+    _sympystr = _sympyrepr
+    def __repr__(self):  # sympy.core.Basic.__repr__ uses sstr
+        from sympy.printing import srepr
+        return srepr(self)
+    def kwargs(self, exclude=(), apply=None):
+        """ Get instance's attributes as dict of keyword arguments.
+        Parameters
+        ==========
+        exclude : collection of str
+            Collection of keywords to exclude.
+        apply : callable, optional
+            Function to apply to all values.
+        """
+        kwargs = {k: getattr(self, k) for k in self._fields if k not in exclude}
+        if apply is not None:
+            return {k: apply(v) for k, v in kwargs.items()}
+        else:
+            return kwargs
+class BreakToken(Token):
+    """ Represents 'break' in C/Python ('exit' in Fortran).
+    Use the premade instance ``break_`` or instantiate manually.
+    Examples
+    ========
+    >>> from sympy import ccode, fcode
+    >>> from sympy.codegen.ast import break_
+    >>> ccode(break_)
+    'break'
+    >>> fcode(break_, source_format='free')
+    'exit'
+    """
+break_ = BreakToken()
+class ContinueToken(Token):
+    """ Represents 'continue' in C/Python ('cycle' in Fortran)
+    Use the premade instance ``continue_`` or instantiate manually.
+    Examples
+    ========
+    >>> from sympy import ccode, fcode
+    >>> from sympy.codegen.ast import continue_
+    >>> ccode(continue_)
+    'continue'
+    >>> fcode(continue_, source_format='free')
+    'cycle'
+    """
+continue_ = ContinueToken()
+class NoneToken(Token):
+    """ The AST equivalence of Python's NoneType
+    The corresponding instance of Python's ``None`` is ``none``.
+    Examples
+    ========
+    >>> from sympy.codegen.ast import none, Variable
+    >>> from sympy import pycode
+    >>> print(pycode(Variable('x').as_Declaration(value=none)))
+    x = None
+    """
+    def __eq__(self, other):
+        return other is None or isinstance(other, NoneToken)
+    def _hashable_content(self):
+        return ()
+    def __hash__(self):
+        return super().__hash__()
+none = NoneToken()
+class AssignmentBase(CodegenAST):
+    """ Abstract base class for Assignment and AugmentedAssignment.
+    Attributes:
+    ===========
+    op : str
+        Symbol for assignment operator, e.g. "=", "+=", etc.
+    """
+    def __new__(cls, lhs, rhs):
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+        cls._check_args(lhs, rhs)
+        return super().__new__(cls, lhs, rhs)
+    @property
+    def lhs(self):
+        return self.args[0]
+    @property
+    def rhs(self):
+        return self.args[1]
+    @classmethod
+    def _check_args(cls, lhs, rhs):
+        """ Check arguments to __new__ and raise exception if any problems found.
+        Derived classes may wish to override this.
+        """
+        from sympy.matrices.expressions.matexpr import (
+            MatrixElement, MatrixSymbol)
+        from sympy.tensor.indexed import Indexed
+        from sympy.tensor.array.expressions import ArrayElement
+        # Tuple of things that can be on the lhs of an assignment
+        assignable = (Symbol, MatrixSymbol, MatrixElement, Indexed, Element, Variable,
+                ArrayElement)
+        if not isinstance(lhs, assignable):
+            raise TypeError("Cannot assign to lhs of type %s." % type(lhs))
+        # Indexed types implement shape, but don't define it until later. This
+        # causes issues in assignment validation. For now, matrices are defined
+        # as anything with a shape that is not an Indexed
+        lhs_is_mat = hasattr(lhs, 'shape') and not isinstance(lhs, Indexed)
+        rhs_is_mat = hasattr(rhs, 'shape') and not isinstance(rhs, Indexed)
+        # If lhs and rhs have same structure, then this assignment is ok
+        if lhs_is_mat:
+            if not rhs_is_mat:
+                raise ValueError("Cannot assign a scalar to a matrix.")
+            elif lhs.shape != rhs.shape:
+                raise ValueError("Dimensions of lhs and rhs do not align.")
+        elif rhs_is_mat and not lhs_is_mat:
+            raise ValueError("Cannot assign a matrix to a scalar.")
+class Assignment(AssignmentBase):
+    """
+    Represents variable assignment for code generation.
+    Parameters
+    ==========
+    lhs : Expr
+        SymPy object representing the lhs of the expression. These should be
+        singular objects, such as one would use in writing code. Notable types
+        include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that
+        subclass these types are also supported.
+    rhs : Expr
+        SymPy object representing the rhs of the expression. This can be any
+        type, provided its shape corresponds to that of the lhs. For example,
+        a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as
+        the dimensions will not align.
+    Examples
+    ========
+    >>> from sympy import symbols, MatrixSymbol, Matrix
+    >>> from sympy.codegen.ast import Assignment
+    >>> x, y, z = symbols('x, y, z')
+    >>> Assignment(x, y)
+    Assignment(x, y)
+    >>> Assignment(x, 0)
+    Assignment(x, 0)
+    >>> A = MatrixSymbol('A', 1, 3)
+    >>> mat = Matrix([x, y, z]).T
+    >>> Assignment(A, mat)
+    Assignment(A, Matrix([[x, y, z]]))
+    >>> Assignment(A[0, 1], x)
+    Assignment(A[0, 1], x)
+    """
+    op = ':='
+class AugmentedAssignment(AssignmentBase):
+    """
+    Base class for augmented assignments.
+    Attributes:
+    ===========
+    binop : str
+       Symbol for binary operation being applied in the assignment, such as "+",
+       "*", etc.
+    """
+    binop = None  # type: str
+    @property
+    def op(self):
+        return self.binop + '='
+class AddAugmentedAssignment(AugmentedAssignment):
+    binop = '+'
+class SubAugmentedAssignment(AugmentedAssignment):
+    binop = '-'
+class MulAugmentedAssignment(AugmentedAssignment):
+    binop = '*'
+class DivAugmentedAssignment(AugmentedAssignment):
+    binop = '/'
+class ModAugmentedAssignment(AugmentedAssignment):
+    binop = '%'
+# Mapping from binary op strings to AugmentedAssignment subclasses
+augassign_classes = {
+    cls.binop: cls for cls in [
+        AddAugmentedAssignment, SubAugmentedAssignment, MulAugmentedAssignment,
+        DivAugmentedAssignment, ModAugmentedAssignment
+    ]
+}
+def aug_assign(lhs, op, rhs):
+    """
+    Create 'lhs op= rhs'.
+    Explanation
+    ===========
+    Represents augmented variable assignment for code generation. This is a
+    convenience function. You can also use the AugmentedAssignment classes
+    directly, like AddAugmentedAssignment(x, y).
+    Parameters
+    ==========
+    lhs : Expr
+        SymPy object representing the lhs of the expression. These should be
+        singular objects, such as one would use in writing code. Notable types
+        include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that
+        subclass these types are also supported.
+    op : str
+        Operator (+, -, /, \\*, %).
+    rhs : Expr
+        SymPy object representing the rhs of the expression. This can be any
+        type, provided its shape corresponds to that of the lhs. For example,
+        a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as
+        the dimensions will not align.
+    Examples
+    ========
+    >>> from sympy import symbols
+    >>> from sympy.codegen.ast import aug_assign
+    >>> x, y = symbols('x, y')
+    >>> aug_assign(x, '+', y)
+    AddAugmentedAssignment(x, y)
+    """
+    if op not in augassign_classes:
+        raise ValueError("Unrecognized operator %s" % op)
+    return augassign_classes[op](lhs, rhs)
+class CodeBlock(CodegenAST):
+    """
+    Represents a block of code.
+    Explanation
+    ===========
+    For now only assignments are supported. This restriction will be lifted in
+    the future.
+    Useful attributes on this object are:
+    ``left_hand_sides``:
+        Tuple of left-hand sides of assignments, in order.
+    ``left_hand_sides``:
+        Tuple of right-hand sides of assignments, in order.
+    ``free_symbols``: Free symbols of the expressions in the right-hand sides
+        which do not appear in the left-hand side of an assignment.
+    Useful methods on this object are:
+    ``topological_sort``:
+        Class method. Return a CodeBlock with assignments
+        sorted so that variables are assigned before they
+        are used.
+    ``cse``:
+        Return a new CodeBlock with common subexpressions eliminated and
+        pulled out as assignments.
+    Examples
+    ========
+    >>> from sympy import symbols, ccode
+    >>> from sympy.codegen.ast import CodeBlock, Assignment
+    >>> x, y = symbols('x y')
+    >>> c = CodeBlock(Assignment(x, 1), Assignment(y, x + 1))
+    >>> print(ccode(c))
+    x = 1;
+    y = x + 1;
+    """
+    def __new__(cls, *args):
+        left_hand_sides = []
+        right_hand_sides = []
+        for i in args:
+            if isinstance(i, Assignment):
+                lhs, rhs = i.args
+                left_hand_sides.append(lhs)
+                right_hand_sides.append(rhs)
+        obj = CodegenAST.__new__(cls, *args)
+        obj.left_hand_sides = Tuple(*left_hand_sides)
+        obj.right_hand_sides = Tuple(*right_hand_sides)
+        return obj
+    def __iter__(self):
+        return iter(self.args)
+    def _sympyrepr(self, printer, *args, **kwargs):
+        il = printer._context.get('indent_level', 0)
+        joiner = ',\n' + ' '*il
+        joined = joiner.join(map(printer._print, self.args))
+        return ('{}(\n'.format(' '*(il-4) + self.__class__.__name__,) +
+                ' '*il + joined + '\n' + ' '*(il - 4) + ')')
+    _sympystr = _sympyrepr
+    @property
+    def free_symbols(self):
+        return super().free_symbols - set(self.left_hand_sides)
+    @classmethod
+    def topological_sort(cls, assignments):
+        """
+        Return a CodeBlock with topologically sorted assignments so that
+        variables are assigned before they are used.
+        Examples
+        ========
+        The existing order of assignments is preserved as much as possible.
+        This function assumes that variables are assigned to only once.
+        This is a class constructor so that the default constructor for
+        CodeBlock can error when variables are used before they are assigned.
+        >>> from sympy import symbols
+        >>> from sympy.codegen.ast import CodeBlock, Assignment
+        >>> x, y, z = symbols('x y z')
+        >>> assignments = [
+        ...     Assignment(x, y + z),
+        ...     Assignment(y, z + 1),
+        ...     Assignment(z, 2),
+        ... ]
+        >>> CodeBlock.topological_sort(assignments)
+        CodeBlock(
+            Assignment(z, 2),
+            Assignment(y, z + 1),
+            Assignment(x, y + z)
+        )
+        """
+        if not all(isinstance(i, Assignment) for i in assignments):
+            # Will support more things later
+            raise NotImplementedError("CodeBlock.topological_sort only supports Assignments")
+        if any(isinstance(i, AugmentedAssignment) for i in assignments):
+            raise NotImplementedError("CodeBlock.topological_sort does not yet work with AugmentedAssignments")
+        # Create a graph where the nodes are assignments and there is a directed edge
+        # between nodes that use a variable and nodes that assign that
+        # variable, like
+        # [(x := 1, y := x + 1), (x := 1, z := y + z), (y := x + 1, z := y + z)]
+        # If we then topologically sort these nodes, they will be in
+        # assignment order, like
+        # x := 1
+        # y := x + 1
+        # z := y + z
+        # A = The nodes
+        #
+        # enumerate keeps nodes in the same order they are already in if
+        # possible. It will also allow us to handle duplicate assignments to
+        # the same variable when those are implemented.
+        A = list(enumerate(assignments))
+        # var_map = {variable: [nodes for which this variable is assigned to]}
+        # like {x: [(1, x := y + z), (4, x := 2 * w)], ...}
+        var_map = defaultdict(list)
+        for node in A:
+            i, a = node
+            var_map[a.lhs].append(node)
+        # E = Edges in the graph
+        E = []
+        for dst_node in A:
+            i, a = dst_node
+            for s in a.rhs.free_symbols:
+                for src_node in var_map[s]:
+                    E.append((src_node, dst_node))
+        ordered_assignments = topological_sort([A, E])
+        # De-enumerate the result
+        return cls(*[a for i, a in ordered_assignments])
+    def cse(self, symbols=None, optimizations=None, postprocess=None,
+        order='canonical'):
+        """
+        Return a new code block with common subexpressions eliminated.
+        Explanation
+        ===========
+        See the docstring of :func:`sympy.simplify.cse_main.cse` for more
+        information.
+        Examples
+        ========
+        >>> from sympy import symbols, sin
+        >>> from sympy.codegen.ast import CodeBlock, Assignment
+        >>> x, y, z = symbols('x y z')
+        >>> c = CodeBlock(
+        ...     Assignment(x, 1),
+        ...     Assignment(y, sin(x) + 1),
+        ...     Assignment(z, sin(x) - 1),
+        ... )
+        ...
+        >>> c.cse()
+        CodeBlock(
+            Assignment(x, 1),
+            Assignment(x0, sin(x)),
+            Assignment(y, x0 + 1),
+            Assignment(z, x0 - 1)
+        )
+        """
+        from sympy.simplify.cse_main import cse
+        # Check that the CodeBlock only contains assignments to unique variables
+        if not all(isinstance(i, Assignment) for i in self.args):
+            # Will support more things later
+            raise NotImplementedError("CodeBlock.cse only supports Assignments")
+        if any(isinstance(i, AugmentedAssignment) for i in self.args):
+            raise NotImplementedError("CodeBlock.cse does not yet work with AugmentedAssignments")
+        for i, lhs in enumerate(self.left_hand_sides):
+            if lhs in self.left_hand_sides[:i]:
+                raise NotImplementedError("Duplicate assignments to the same "
+                    "variable are not yet supported (%s)" % lhs)
+        # Ensure new symbols for subexpressions do not conflict with existing
+        existing_symbols = self.atoms(Symbol)
+        if symbols is None:
+            symbols = numbered_symbols()
+        symbols = filter_symbols(symbols, existing_symbols)
+        replacements, reduced_exprs = cse(list(self.right_hand_sides),
+            symbols=symbols, optimizations=optimizations, postprocess=postprocess,
+            order=order)
+        new_block = [Assignment(var, expr) for var, expr in
+            zip(self.left_hand_sides, reduced_exprs)]
+        new_assignments = [Assignment(var, expr) for var, expr in replacements]
+        return self.topological_sort(new_assignments + new_block)
+class For(Token):
+    """Represents a 'for-loop' in the code.
+    Expressions are of the form:
+        "for target in iter:
+            body..."
+    Parameters
+    ==========
+    target : symbol
+    iter : iterable
+    body : CodeBlock or iterable
+!        When passed an iterable it is used to instantiate a CodeBlock.
+    Examples
+    ========
+    >>> from sympy import symbols, Range
+    >>> from sympy.codegen.ast import aug_assign, For
+    >>> x, i, j, k = symbols('x i j k')
+    >>> for_i = For(i, Range(10), [aug_assign(x, '+', i*j*k)])
+    >>> for_i  # doctest: -NORMALIZE_WHITESPACE
+    For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+        AddAugmentedAssignment(x, i*j*k)
+    ))
+    >>> for_ji = For(j, Range(7), [for_i])
+    >>> for_ji  # doctest: -NORMALIZE_WHITESPACE
+    For(j, iterable=Range(0, 7, 1), body=CodeBlock(
+        For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+            AddAugmentedAssignment(x, i*j*k)
+        ))
+    ))
+    >>> for_kji =For(k, Range(5), [for_ji])
+    >>> for_kji  # doctest: -NORMALIZE_WHITESPACE
+    For(k, iterable=Range(0, 5, 1), body=CodeBlock(
+        For(j, iterable=Range(0, 7, 1), body=CodeBlock(
+            For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+                AddAugmentedAssignment(x, i*j*k)
+            ))
+        ))
+    ))
+    """
+    __slots__ = _fields = ('target', 'iterable', 'body')
+    _construct_target = staticmethod(_sympify)
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+    @classmethod
+    def _construct_iterable(cls, itr):
+        if not iterable(itr):
+            raise TypeError("iterable must be an iterable")
+        if isinstance(itr, list):  # _sympify errors on lists because they are mutable
+            itr = tuple(itr)
+        return _sympify(itr)
+class String(Atom, Token):
+    """ SymPy object representing a string.
+    Atomic object which is not an expression (as opposed to Symbol).
+    Parameters
+    ==========
+    text : str
+    Examples
+    ========
+    >>> from sympy.codegen.ast import String
+    >>> f = String('foo')
+    >>> f
+    foo
+    >>> str(f)
+    'foo'
+    >>> f.text
+    'foo'
+    >>> print(repr(f))
+    String('foo')
+    """
+    __slots__ = _fields = ('text',)
+    not_in_args = ['text']
+    is_Atom = True
+    @classmethod
+    def _construct_text(cls, text):
+        if not isinstance(text, str):
+            raise TypeError("Argument text is not a string type.")
+        return text
+    def _sympystr(self, printer, *args, **kwargs):
+        return self.text
+    def kwargs(self, exclude = (), apply = None):
+        return {}
+    #to be removed when Atom is given a suitable func
+    @property
+    def func(self):
+        return lambda: self
+    def _latex(self, printer):
+        from sympy.printing.latex import latex_escape
+        return r'\texttt{{"{}"}}'.format(latex_escape(self.text))
+class QuotedString(String):
+    """ Represents a string which should be printed with quotes. """
+class Comment(String):
+    """ Represents a comment. """
+class Node(Token):
+    """ Subclass of Token, carrying the attribute 'attrs' (Tuple)
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Node, value_const, pointer_const
+    >>> n1 = Node([value_const])
+    >>> n1.attr_params('value_const')  # get the parameters of attribute (by name)
+    ()
+    >>> from sympy.codegen.fnodes import dimension
+    >>> n2 = Node([value_const, dimension(5, 3)])
+    >>> n2.attr_params(value_const)  # get the parameters of attribute (by Attribute instance)
+    ()
+    >>> n2.attr_params('dimension')  # get the parameters of attribute (by name)
+    (5, 3)
+    >>> n2.attr_params(pointer_const) is None
+    True
+    """
+    __slots__: tuple[str, ...] = ('attrs',)
+    _fields = __slots__
+    defaults: dict[str, Any] = {'attrs': Tuple()}
+    _construct_attrs = staticmethod(_mk_Tuple)
+    def attr_params(self, looking_for):
+        """ Returns the parameters of the Attribute with name ``looking_for`` in self.attrs """
+        for attr in self.attrs:
+            if str(attr.name) == str(looking_for):
+                return attr.parameters
+class Type(Token):
+    """ Represents a type.
+    Explanation
+    ===========
+    The naming is a super-set of NumPy naming. Type has a classmethod
+    ``from_expr`` which offer type deduction. It also has a method
+    ``cast_check`` which casts the argument to its type, possibly raising an
+    exception if rounding error is not within tolerances, or if the value is not
+    representable by the underlying data type (e.g. unsigned integers).
+    Parameters
+    ==========
+    name : str
+        Name of the type, e.g. ``object``, ``int16``, ``float16`` (where the latter two
+        would use the ``Type`` sub-classes ``IntType`` and ``FloatType`` respectively).
+        If a ``Type`` instance is given, the said instance is returned.
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Type
+    >>> t = Type.from_expr(42)
+    >>> t
+    integer
+    >>> print(repr(t))
+    IntBaseType(String('integer'))
+    >>> from sympy.codegen.ast import uint8
+    >>> uint8.cast_check(-1)   # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Minimum value for data type bigger than new value.
+    >>> from sympy.codegen.ast import float32
+    >>> v6 = 0.123456
+    >>> float32.cast_check(v6)
+    0.123456
+    >>> v10 = 12345.67894
+    >>> float32.cast_check(v10)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Casting gives a significantly different value.
+    >>> boost_mp50 = Type('boost::multiprecision::cpp_dec_float_50')
+    >>> from sympy import cxxcode
+    >>> from sympy.codegen.ast import Declaration, Variable
+    >>> cxxcode(Declaration(Variable('x', type=boost_mp50)))
+    'boost::multiprecision::cpp_dec_float_50 x'
+    References
+    ==========
+    .. [1] https://numpy.org/doc/stable/user/basics.types.html
+    """
+    __slots__: tuple[str, ...] = ('name',)
+    _fields = __slots__
+    _construct_name = String
+    def _sympystr(self, printer, *args, **kwargs):
+        return str(self.name)
+    @classmethod
+    def from_expr(cls, expr):
+        """ Deduces type from an expression or a ``Symbol``.
+        Parameters
+        ==========
+        expr : number or SymPy object
+            The type will be deduced from type or properties.
+        Examples
+        ========
+        >>> from sympy.codegen.ast import Type, integer, complex_
+        >>> Type.from_expr(2) == integer
+        True
+        >>> from sympy import Symbol
+        >>> Type.from_expr(Symbol('z', complex=True)) == complex_
+        True
+        >>> Type.from_expr(sum)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Could not deduce type from expr.
+        Raises
+        ======
+        ValueError when type deduction fails.
+        """
+        if isinstance(expr, (float, Float)):
+            return real
+        if isinstance(expr, (int, Integer)) or getattr(expr, 'is_integer', False):
+            return integer
+        if getattr(expr, 'is_real', False):
+            return real
+        if isinstance(expr, complex) or getattr(expr, 'is_complex', False):
+            return complex_
+        if isinstance(expr, bool) or getattr(expr, 'is_Relational', False):
+            return bool_
+        else:
+            raise ValueError("Could not deduce type from expr.")
+    def _check(self, value):
+        pass
+    def cast_check(self, value, rtol=None, atol=0, precision_targets=None):
+        """ Casts a value to the data type of the instance.
+        Parameters
+        ==========
+        value : number
+        rtol : floating point number
+            Relative tolerance. (will be deduced if not given).
+        atol : floating point number
+            Absolute tolerance (in addition to ``rtol``).
+        type_aliases : dict
+            Maps substitutions for Type, e.g. {integer: int64, real: float32}
+        Examples
+        ========
+        >>> from sympy.codegen.ast import integer, float32, int8
+        >>> integer.cast_check(3.0) == 3
+        True
+        >>> float32.cast_check(1e-40)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Minimum value for data type bigger than new value.
+        >>> int8.cast_check(256)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Maximum value for data type smaller than new value.
+        >>> v10 = 12345.67894
+        >>> float32.cast_check(v10)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Casting gives a significantly different value.
+        >>> from sympy.codegen.ast import float64
+        >>> float64.cast_check(v10)
+        12345.67894
+        >>> from sympy import Float
+        >>> v18 = Float('0.123456789012345646')
+        >>> float64.cast_check(v18)
+        Traceback (most recent call last):
+          ...
+        ValueError: Casting gives a significantly different value.
+        >>> from sympy.codegen.ast import float80
+        >>> float80.cast_check(v18)
+        0.123456789012345649
+        """
+        val = sympify(value)
+        ten = Integer(10)
+        exp10 = getattr(self, 'decimal_dig', None)
+        if rtol is None:
+            rtol = 1e-15 if exp10 is None else 2.0*ten**(-exp10)
+        def tol(num):
+            return atol + rtol*abs(num)
+        new_val = self.cast_nocheck(value)
+        self._check(new_val)
+        delta = new_val - val
+        if abs(delta) > tol(val):  # rounding, e.g. int(3.5) != 3.5
+            raise ValueError("Casting gives a significantly different value.")
+        return new_val
+    def _latex(self, printer):
+        from sympy.printing.latex import latex_escape
+        type_name = latex_escape(self.__class__.__name__)
+        name = latex_escape(self.name.text)
+        return r"\text{{{}}}\left(\texttt{{{}}}\right)".format(type_name, name)
+class IntBaseType(Type):
+    """ Integer base type, contains no size information. """
+    __slots__ = ()
+    cast_nocheck = lambda self, i: Integer(int(i))
+class _SizedIntType(IntBaseType):
+    __slots__ = ('nbits',)
+    _fields = Type._fields + __slots__
+    _construct_nbits = Integer
+    def _check(self, value):
+        if value < self.min:
+            raise ValueError("Value is too small: %d < %d" % (value, self.min))
+        if value > self.max:
+            raise ValueError("Value is too big: %d > %d" % (value, self.max))
+class SignedIntType(_SizedIntType):
+    """ Represents a signed integer type. """
+    __slots__ = ()
+    @property
+    def min(self):
+        return -2**(self.nbits-1)
+    @property
+    def max(self):
+        return 2**(self.nbits-1) - 1
+class UnsignedIntType(_SizedIntType):
+    """ Represents an unsigned integer type. """
+    __slots__ = ()
+    @property
+    def min(self):
+        return 0
+    @property
+    def max(self):
+        return 2**self.nbits - 1
+two = Integer(2)
+class FloatBaseType(Type):
+    """ Represents a floating point number type. """
+    __slots__ = ()
+    cast_nocheck = Float
+class FloatType(FloatBaseType):
+    """ Represents a floating point type with fixed bit width.
+    Base 2 & one sign bit is assumed.
+    Parameters
+    ==========
+    name : str
+        Name of the type.
+    nbits : integer
+        Number of bits used (storage).
+    nmant : integer
+        Number of bits used to represent the mantissa.
+    nexp : integer
+        Number of bits used to represent the mantissa.
+    Examples
+    ========
+    >>> from sympy import S
+    >>> from sympy.codegen.ast import FloatType
+    >>> half_precision = FloatType('f16', nbits=16, nmant=10, nexp=5)
+    >>> half_precision.max
+    65504
+    >>> half_precision.tiny == S(2)**-14
+    True
+    >>> half_precision.eps == S(2)**-10
+    True
+    >>> half_precision.dig == 3
+    True
+    >>> half_precision.decimal_dig == 5
+    True
+    >>> half_precision.cast_check(1.0)
+    1.0
+    >>> half_precision.cast_check(1e5)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Maximum value for data type smaller than new value.
+    """
+    __slots__ = ('nbits', 'nmant', 'nexp',)
+    _fields = Type._fields + __slots__
+    _construct_nbits = _construct_nmant = _construct_nexp = Integer
+    @property
+    def max_exponent(self):
+        """ The largest positive number n, such that 2**(n - 1) is a representable finite value. """
+        # cf. C++'s ``std::numeric_limits::max_exponent``
+        return two**(self.nexp - 1)
+    @property
+    def min_exponent(self):
+        """ The lowest negative number n, such that 2**(n - 1) is a valid normalized number. """
+        # cf. C++'s ``std::numeric_limits::min_exponent``
+        return 3 - self.max_exponent
+    @property
+    def max(self):
+        """ Maximum value representable. """
+        return (1 - two**-(self.nmant+1))*two**self.max_exponent
+    @property
+    def tiny(self):
+        """ The minimum positive normalized value. """
+        # See C macros: FLT_MIN, DBL_MIN, LDBL_MIN
+        # or C++'s ``std::numeric_limits::min``
+        # or numpy.finfo(dtype).tiny
+        return two**(self.min_exponent - 1)
+    @property
+    def eps(self):
+        """ Difference between 1.0 and the next representable value. """
+        return two**(-self.nmant)
+    @property
+    def dig(self):
+        """ Number of decimal digits that are guaranteed to be preserved in text.
+        When converting text -> float -> text, you are guaranteed that at least ``dig``
+        number of digits are preserved with respect to rounding or overflow.
+        """
+        from sympy.functions import floor, log
+        return floor(self.nmant * log(2)/log(10))
+    @property
+    def decimal_dig(self):
+        """ Number of digits needed to store & load without loss.
+        Explanation
+        ===========
+        Number of decimal digits needed to guarantee that two consecutive conversions
+        (float -> text -> float) to be idempotent. This is useful when one do not want
+        to loose precision due to rounding errors when storing a floating point value
+        as text.
+        """
+        from sympy.functions import ceiling, log
+        return ceiling((self.nmant + 1) * log(2)/log(10) + 1)
+    def cast_nocheck(self, value):
+        """ Casts without checking if out of bounds or subnormal. """
+        if value == oo:  # float(oo) or oo
+            return float(oo)
+        elif value == -oo:  # float(-oo) or -oo
+            return float(-oo)
+        return Float(str(sympify(value).evalf(self.decimal_dig)), self.decimal_dig)
+    def _check(self, value):
+        if value < -self.max:
+            raise ValueError("Value is too small: %d < %d" % (value, -self.max))
+        if value > self.max:
+            raise ValueError("Value is too big: %d > %d" % (value, self.max))
+        if abs(value) < self.tiny:
+            raise ValueError("Smallest (absolute) value for data type bigger than new value.")
+class ComplexBaseType(FloatBaseType):
+    __slots__ = ()
+    def cast_nocheck(self, value):
+        """ Casts without checking if out of bounds or subnormal. """
+        from sympy.functions import re, im
+        return (
+            super().cast_nocheck(re(value)) +
+            super().cast_nocheck(im(value))*1j
+        )
+    def _check(self, value):
+        from sympy.functions import re, im
+        super()._check(re(value))
+        super()._check(im(value))
+class ComplexType(ComplexBaseType, FloatType):
+    """ Represents a complex floating point number. """
+    __slots__ = ()
+# NumPy types:
+intc = IntBaseType('intc')
+intp = IntBaseType('intp')
+int8 = SignedIntType('int8', 8)
+int16 = SignedIntType('int16', 16)
+int32 = SignedIntType('int32', 32)
+int64 = SignedIntType('int64', 64)
+uint8 = UnsignedIntType('uint8', 8)
+uint16 = UnsignedIntType('uint16', 16)
+uint32 = UnsignedIntType('uint32', 32)
+uint64 = UnsignedIntType('uint64', 64)
+float16 = FloatType('float16', 16, nexp=5, nmant=10)  # IEEE 754 binary16, Half precision
+float32 = FloatType('float32', 32, nexp=8, nmant=23)  # IEEE 754 binary32, Single precision
+float64 = FloatType('float64', 64, nexp=11, nmant=52)  # IEEE 754 binary64, Double precision
+float80 = FloatType('float80', 80, nexp=15, nmant=63)  # x86 extended precision (1 integer part bit), "long double"
+float128 = FloatType('float128', 128, nexp=15, nmant=112)  # IEEE 754 binary128, Quadruple precision
+float256 = FloatType('float256', 256, nexp=19, nmant=236)  # IEEE 754 binary256, Octuple precision
+complex64 = ComplexType('complex64', nbits=64, **float32.kwargs(exclude=('name', 'nbits')))
+complex128 = ComplexType('complex128', nbits=128, **float64.kwargs(exclude=('name', 'nbits')))
+# Generic types (precision may be chosen by code printers):
+untyped = Type('untyped')
+real = FloatBaseType('real')
+integer = IntBaseType('integer')
+complex_ = ComplexBaseType('complex')
+bool_ = Type('bool')
+class Attribute(Token):
+    """ Attribute (possibly parametrized)
+    For use with :class:`sympy.codegen.ast.Node` (which takes instances of
+    ``Attribute`` as ``attrs``).
+    Parameters
+    ==========
+    name : str
+    parameters : Tuple
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Attribute
+    >>> volatile = Attribute('volatile')
+    >>> volatile
+    volatile
+    >>> print(repr(volatile))
+    Attribute(String('volatile'))
+    >>> a = Attribute('foo', [1, 2, 3])
+    >>> a
+    foo(1, 2, 3)
+    >>> a.parameters == (1, 2, 3)
+    True
+    """
+    __slots__ = _fields = ('name', 'parameters')
+    defaults = {'parameters': Tuple()}
+    _construct_name = String
+    _construct_parameters = staticmethod(_mk_Tuple)
+    def _sympystr(self, printer, *args, **kwargs):
+        result = str(self.name)
+        if self.parameters:
+            result += '(%s)' % ', '.join((printer._print(
+                arg, *args, **kwargs) for arg in self.parameters))
+        return result
+value_const = Attribute('value_const')
+pointer_const = Attribute('pointer_const')
+class Variable(Node):
+    """ Represents a variable.
+    Parameters
+    ==========
+    symbol : Symbol
+    type : Type (optional)
+        Type of the variable.
+    attrs : iterable of Attribute instances
+        Will be stored as a Tuple.
+    Examples
+    ========
+    >>> from sympy import Symbol
+    >>> from sympy.codegen.ast import Variable, float32, integer
+    >>> x = Symbol('x')
+    >>> v = Variable(x, type=float32)
+    >>> v.attrs
+    ()
+    >>> v == Variable('x')
+    False
+    >>> v == Variable('x', type=float32)
+    True
+    >>> v
+    Variable(x, type=float32)
+    One may also construct a ``Variable`` instance with the type deduced from
+    assumptions about the symbol using the ``deduced`` classmethod:
+    >>> i = Symbol('i', integer=True)
+    >>> v = Variable.deduced(i)
+    >>> v.type == integer
+    True
+    >>> v == Variable('i')
+    False
+    >>> from sympy.codegen.ast import value_const
+    >>> value_const in v.attrs
+    False
+    >>> w = Variable('w', attrs=[value_const])
+    >>> w
+    Variable(w, attrs=(value_const,))
+    >>> value_const in w.attrs
+    True
+    >>> w.as_Declaration(value=42)
+    Declaration(Variable(w, value=42, attrs=(value_const,)))
+    """
+    __slots__ = ('symbol', 'type', 'value')
+    _fields = __slots__ + Node._fields
+    defaults = Node.defaults.copy()
+    defaults.update({'type': untyped, 'value': none})
+    _construct_symbol = staticmethod(sympify)
+    _construct_value = staticmethod(sympify)
+    @classmethod
+    def deduced(cls, symbol, value=None, attrs=Tuple(), cast_check=True):
+        """ Alt. constructor with type deduction from ``Type.from_expr``.
+        Deduces type primarily from ``symbol``, secondarily from ``value``.
+        Parameters
+        ==========
+        symbol : Symbol
+        value : expr
+            (optional) value of the variable.
+        attrs : iterable of Attribute instances
+        cast_check : bool
+            Whether to apply ``Type.cast_check`` on ``value``.
+        Examples
+        ========
+        >>> from sympy import Symbol
+        >>> from sympy.codegen.ast import Variable, complex_
+        >>> n = Symbol('n', integer=True)
+        >>> str(Variable.deduced(n).type)
+        'integer'
+        >>> x = Symbol('x', real=True)
+        >>> v = Variable.deduced(x)
+        >>> v.type
+        real
+        >>> z = Symbol('z', complex=True)
+        >>> Variable.deduced(z).type == complex_
+        True
+        """
+        if isinstance(symbol, Variable):
+            return symbol
+        try:
+            type_ = Type.from_expr(symbol)
+        except ValueError:
+            type_ = Type.from_expr(value)
+        if value is not None and cast_check:
+            value = type_.cast_check(value)
+        return cls(symbol, type=type_, value=value, attrs=attrs)
+    def as_Declaration(self, **kwargs):
+        """ Convenience method for creating a Declaration instance.
+        Explanation
+        ===========
+        If the variable of the Declaration need to wrap a modified
+        variable keyword arguments may be passed (overriding e.g.
+        the ``value`` of the Variable instance).
+        Examples
+        ========
+        >>> from sympy.codegen.ast import Variable, NoneToken
+        >>> x = Variable('x')
+        >>> decl1 = x.as_Declaration()
+        >>> # value is special NoneToken() which must be tested with == operator
+        >>> decl1.variable.value is None  # won't work
+        False
+        >>> decl1.variable.value == None  # not PEP-8 compliant
+        True
+        >>> decl1.variable.value == NoneToken()  # OK
+        True
+        >>> decl2 = x.as_Declaration(value=42.0)
+        >>> decl2.variable.value == 42.0
+        True
+        """
+        kw = self.kwargs()
+        kw.update(kwargs)
+        return Declaration(self.func(**kw))
+    def _relation(self, rhs, op):
+        try:
+            rhs = _sympify(rhs)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s < %s" % (self, rhs))
+        return op(self, rhs, evaluate=False)
+    __lt__ = lambda self, other: self._relation(other, Lt)
+    __le__ = lambda self, other: self._relation(other, Le)
+    __ge__ = lambda self, other: self._relation(other, Ge)
+    __gt__ = lambda self, other: self._relation(other, Gt)
+class Pointer(Variable):
+    """ Represents a pointer. See ``Variable``.
+    Examples
+    ========
+    Can create instances of ``Element``:
+    >>> from sympy import Symbol
+    >>> from sympy.codegen.ast import Pointer
+    >>> i = Symbol('i', integer=True)
+    >>> p = Pointer('x')
+    >>> p[i+1]
+    Element(x, indices=(i + 1,))
+    """
+    __slots__ = ()
+    def __getitem__(self, key):
+        try:
+            return Element(self.symbol, key)
+        except TypeError:
+            return Element(self.symbol, (key,))
+class Element(Token):
+    """ Element in (a possibly N-dimensional) array.
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Element
+    >>> elem = Element('x', 'ijk')
+    >>> elem.symbol.name == 'x'
+    True
+    >>> elem.indices
+    (i, j, k)
+    >>> from sympy import ccode
+    >>> ccode(elem)
+    'x[i][j][k]'
+    >>> ccode(Element('x', 'ijk', strides='lmn', offset='o'))
+    'x[i*l + j*m + k*n + o]'
+    """
+    __slots__ = _fields = ('symbol', 'indices', 'strides', 'offset')
+    defaults = {'strides': none, 'offset': none}
+    _construct_symbol = staticmethod(sympify)
+    _construct_indices = staticmethod(lambda arg: Tuple(*arg))
+    _construct_strides = staticmethod(lambda arg: Tuple(*arg))
+    _construct_offset = staticmethod(sympify)
+class Declaration(Token):
+    """ Represents a variable declaration
+    Parameters
+    ==========
+    variable : Variable
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Declaration, NoneToken, untyped
+    >>> z = Declaration('z')
+    >>> z.variable.type == untyped
+    True
+    >>> # value is special NoneToken() which must be tested with == operator
+    >>> z.variable.value is None  # won't work
+    False
+    >>> z.variable.value == None  # not PEP-8 compliant
+    True
+    >>> z.variable.value == NoneToken()  # OK
+    True
+    """
+    __slots__ = _fields = ('variable',)
+    _construct_variable = Variable
+class While(Token):
+    """ Represents a 'for-loop' in the code.
+    Expressions are of the form:
+        "while condition:
+             body..."
+    Parameters
+    ==========
+    condition : expression convertible to Boolean
+    body : CodeBlock or iterable
+        When passed an iterable it is used to instantiate a CodeBlock.
+    Examples
+    ========
+    >>> from sympy import symbols, Gt, Abs
+    >>> from sympy.codegen import aug_assign, Assignment, While
+    >>> x, dx = symbols('x dx')
+    >>> expr = 1 - x**2
+    >>> whl = While(Gt(Abs(dx), 1e-9), [
+    ...     Assignment(dx, -expr/expr.diff(x)),
+    ...     aug_assign(x, '+', dx)
+    ... ])
+    """
+    __slots__ = _fields = ('condition', 'body')
+    _construct_condition = staticmethod(lambda cond: _sympify(cond))
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+class Scope(Token):
+    """ Represents a scope in the code.
+    Parameters
+    ==========
+    body : CodeBlock or iterable
+        When passed an iterable it is used to instantiate a CodeBlock.
+    """
+    __slots__ = _fields = ('body',)
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+class Stream(Token):
+    """ Represents a stream.
+    There are two predefined Stream instances ``stdout`` & ``stderr``.
+    Parameters
+    ==========
+    name : str
+    Examples
+    ========
+    >>> from sympy import pycode, Symbol
+    >>> from sympy.codegen.ast import Print, stderr, QuotedString
+    >>> print(pycode(Print(['x'], file=stderr)))
+    print(x, file=sys.stderr)
+    >>> x = Symbol('x')
+    >>> print(pycode(Print([QuotedString('x')], file=stderr)))  # print literally "x"
+    print("x", file=sys.stderr)
+    """
+    __slots__ = _fields = ('name',)
+    _construct_name = String
+stdout = Stream('stdout')
+stderr = Stream('stderr')
+class Print(Token):
+    r""" Represents print command in the code.
+    Parameters
+    ==========
+    formatstring : str
+    *args : Basic instances (or convertible to such through sympify)
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Print
+    >>> from sympy import pycode
+    >>> print(pycode(Print('x y'.split(), "coordinate: %12.5g %12.5g\\n")))
+    print("coordinate: %12.5g %12.5g\n" % (x, y), end="")
+    """
+    __slots__ = _fields = ('print_args', 'format_string', 'file')
+    defaults = {'format_string': none, 'file': none}
+    _construct_print_args = staticmethod(_mk_Tuple)
+    _construct_format_string = QuotedString
+    _construct_file = Stream
+class FunctionPrototype(Node):
+    """ Represents a function prototype
+    Allows the user to generate forward declaration in e.g. C/C++.
+    Parameters
+    ==========
+    return_type : Type
+    name : str
+    parameters: iterable of Variable instances
+    attrs : iterable of Attribute instances
+    Examples
+    ========
+    >>> from sympy import ccode, symbols
+    >>> from sympy.codegen.ast import real, FunctionPrototype
+    >>> x, y = symbols('x y', real=True)
+    >>> fp = FunctionPrototype(real, 'foo', [x, y])
+    >>> ccode(fp)
+    'double foo(double x, double y)'
+    """
+    __slots__ = ('return_type', 'name', 'parameters')
+    _fields: tuple[str, ...] = __slots__ + Node._fields
+    _construct_return_type = Type
+    _construct_name = String
+    @staticmethod
+    def _construct_parameters(args):
+        def _var(arg):
+            if isinstance(arg, Declaration):
+                return arg.variable
+            elif isinstance(arg, Variable):
+                return arg
+            else:
+                return Variable.deduced(arg)
+        return Tuple(*map(_var, args))
+    @classmethod
+    def from_FunctionDefinition(cls, func_def):
+        if not isinstance(func_def, FunctionDefinition):
+            raise TypeError("func_def is not an instance of FunctionDefinition")
+        return cls(**func_def.kwargs(exclude=('body',)))
+class FunctionDefinition(FunctionPrototype):
+    """ Represents a function definition in the code.
+    Parameters
+    ==========
+    return_type : Type
+    name : str
+    parameters: iterable of Variable instances
+    body : CodeBlock or iterable
+    attrs : iterable of Attribute instances
+    Examples
+    ========
+    >>> from sympy import ccode, symbols
+    >>> from sympy.codegen.ast import real, FunctionPrototype
+    >>> x, y = symbols('x y', real=True)
+    >>> fp = FunctionPrototype(real, 'foo', [x, y])
+    >>> ccode(fp)
+    'double foo(double x, double y)'
+    >>> from sympy.codegen.ast import FunctionDefinition, Return
+    >>> body = [Return(x*y)]
+    >>> fd = FunctionDefinition.from_FunctionPrototype(fp, body)
+    >>> print(ccode(fd))
+    double foo(double x, double y){
+        return x*y;
+    }
+    """
+    __slots__ = ('body', )
+    _fields = FunctionPrototype._fields[:-1] + __slots__ + Node._fields
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+    @classmethod
+    def from_FunctionPrototype(cls, func_proto, body):
+        if not isinstance(func_proto, FunctionPrototype):
+            raise TypeError("func_proto is not an instance of FunctionPrototype")
+        return cls(body=body, **func_proto.kwargs())
+class Return(Token):
+    """ Represents a return command in the code.
+    Parameters
+    ==========
+    return : Basic
+    Examples
+    ========
+    >>> from sympy.codegen.ast import Return
+    >>> from sympy.printing.pycode import pycode
+    >>> from sympy import Symbol
+    >>> x = Symbol('x')
+    >>> print(pycode(Return(x)))
+    return x
+    """
+    __slots__ = _fields = ('return',)
+    _construct_return=staticmethod(_sympify)
+class FunctionCall(Token, Expr):
+    """ Represents a call to a function in the code.
+    Parameters
+    ==========
+    name : str
+    function_args : Tuple
+    Examples
+    ========
+    >>> from sympy.codegen.ast import FunctionCall
+    >>> from sympy import pycode
+    >>> fcall = FunctionCall('foo', 'bar baz'.split())
+    >>> print(pycode(fcall))
+    foo(bar, baz)
+    """
+    __slots__ = _fields = ('name', 'function_args')
+    _construct_name = String
+    _construct_function_args = staticmethod(lambda args: Tuple(*args))
+class Raise(Token):
+    """ Prints as 'raise ...' in Python, 'throw ...' in C++"""
+    __slots__ = _fields = ('exception',)
+class RuntimeError_(Token):
+    """ Represents 'std::runtime_error' in C++ and 'RuntimeError' in Python.
+    Note that the latter is uncommon, and you might want to use e.g. ValueError.
+    """
+    __slots__ = _fields = ('message',)
+    _construct_message = String

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/cnodes.py ADDED Viewed

	@@ -0,0 +1,156 @@

+"""
+AST nodes specific to the C family of languages
+"""
+from sympy.codegen.ast import (
+    Attribute, Declaration, Node, String, Token, Type, none,
+    FunctionCall, CodeBlock
+    )
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.sympify import sympify
+void = Type('void')
+restrict = Attribute('restrict')  # guarantees no pointer aliasing
+volatile = Attribute('volatile')
+static = Attribute('static')
+def alignof(arg):
+    """ Generate of FunctionCall instance for calling 'alignof' """
+    return FunctionCall('alignof', [String(arg) if isinstance(arg, str) else arg])
+def sizeof(arg):
+    """ Generate of FunctionCall instance for calling 'sizeof'
+    Examples
+    ========
+    >>> from sympy.codegen.ast import real
+    >>> from sympy.codegen.cnodes import sizeof
+    >>> from sympy import ccode
+    >>> ccode(sizeof(real))
+    'sizeof(double)'
+    """
+    return FunctionCall('sizeof', [String(arg) if isinstance(arg, str) else arg])
+class CommaOperator(Basic):
+    """ Represents the comma operator in C """
+    def __new__(cls, *args):
+        return Basic.__new__(cls, *[sympify(arg) for arg in args])
+class Label(Node):
+    """ Label for use with e.g. goto statement.
+    Examples
+    ========
+    >>> from sympy import ccode, Symbol
+    >>> from sympy.codegen.cnodes import Label, PreIncrement
+    >>> print(ccode(Label('foo')))
+    foo:
+    >>> print(ccode(Label('bar', [PreIncrement(Symbol('a'))])))
+    bar:
+    ++(a);
+    """
+    __slots__ = _fields = ('name', 'body')
+    defaults = {'body': none}
+    _construct_name = String
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+class goto(Token):
+    """ Represents goto in C """
+    __slots__ = _fields = ('label',)
+    _construct_label = Label
+class PreDecrement(Basic):
+    """ Represents the pre-decrement operator
+    Examples
+    ========
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreDecrement
+    >>> from sympy import ccode
+    >>> ccode(PreDecrement(x))
+    '--(x)'
+    """
+    nargs = 1
+class PostDecrement(Basic):
+    """ Represents the post-decrement operator
+    Examples
+    ========
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostDecrement
+    >>> from sympy import ccode
+    >>> ccode(PostDecrement(x))
+    '(x)--'
+    """
+    nargs = 1
+class PreIncrement(Basic):
+    """ Represents the pre-increment operator
+    Examples
+    ========
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreIncrement
+    >>> from sympy import ccode
+    >>> ccode(PreIncrement(x))
+    '++(x)'
+    """
+    nargs = 1
+class PostIncrement(Basic):
+    """ Represents the post-increment operator
+    Examples
+    ========
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostIncrement
+    >>> from sympy import ccode
+    >>> ccode(PostIncrement(x))
+    '(x)++'
+    """
+    nargs = 1
+class struct(Node):
+    """ Represents a struct in C """
+    __slots__ = _fields = ('name', 'declarations')
+    defaults = {'name': none}
+    _construct_name = String
+    @classmethod
+    def _construct_declarations(cls, args):
+        return Tuple(*[Declaration(arg) for arg in args])
+class union(struct):
+    """ Represents a union in C """
+    __slots__ = ()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/cutils.py ADDED Viewed

	@@ -0,0 +1,8 @@

+from sympy.printing.c import C99CodePrinter
+def render_as_source_file(content, Printer=C99CodePrinter, settings=None):
+    """ Renders a C source file (with required #include statements) """
+    printer = Printer(settings or {})
+    code_str = printer.doprint(content)
+    includes = '\n'.join(['#include <%s>' % h for h in printer.headers])
+    return includes + '\n\n' + code_str

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/futils.py ADDED Viewed

	@@ -0,0 +1,40 @@

+from itertools import chain
+from sympy.codegen.fnodes import Module
+from sympy.core.symbol import Dummy
+from sympy.printing.fortran import FCodePrinter
+""" This module collects utilities for rendering Fortran code. """
+def render_as_module(definitions, name, declarations=(), printer_settings=None):
+    """ Creates a ``Module`` instance and renders it as a string.
+    This generates Fortran source code for a module with the correct ``use`` statements.
+    Parameters
+    ==========
+    definitions : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    name : str
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    declarations : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`. It will be extended with
+        use statements, 'implicit none' and public list generated from ``definitions``.
+    printer_settings : dict
+        Passed to ``FCodePrinter`` (default: ``{'standard': 2003, 'source_format': 'free'}``).
+    """
+    printer_settings = printer_settings or {'standard': 2003, 'source_format': 'free'}
+    printer = FCodePrinter(printer_settings)
+    dummy = Dummy()
+    if isinstance(definitions, Module):
+        raise ValueError("This function expects to construct a module on its own.")
+    mod = Module(name, chain(declarations, [dummy]), definitions)
+    fstr = printer.doprint(mod)
+    module_use_str = '   %s\n' % '   \n'.join(['use %s, only: %s' % (k, ', '.join(v)) for
+                                                k, v in printer.module_uses.items()])
+    module_use_str += '   implicit none\n'
+    module_use_str += '   private\n'
+    module_use_str += '   public %s\n' % ', '.join([str(node.name) for node in definitions if getattr(node, 'name', None)])
+    return fstr.replace(printer.doprint(dummy), module_use_str)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/matrix_nodes.py ADDED Viewed

	@@ -0,0 +1,71 @@

+"""
+Additional AST nodes for operations on matrices. The nodes in this module
+are meant to represent optimization of matrix expressions within codegen's
+target languages that cannot be represented by SymPy expressions.
+As an example, we can use :meth:`sympy.codegen.rewriting.optimize` and the
+``matin_opt`` optimization provided in :mod:`sympy.codegen.rewriting` to
+transform matrix multiplication under certain assumptions:
+    >>> from sympy import symbols, MatrixSymbol
+    >>> n = symbols('n', integer=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> x = MatrixSymbol('x', n, 1)
+    >>> expr = A**(-1) * x
+    >>> from sympy import assuming, Q
+    >>> from sympy.codegen.rewriting import matinv_opt, optimize
+    >>> with assuming(Q.fullrank(A)):
+    ...     optimize(expr, [matinv_opt])
+    MatrixSolve(A, vector=x)
+"""
+from .ast import Token
+from sympy.matrices import MatrixExpr
+from sympy.core.sympify import sympify
+class MatrixSolve(Token, MatrixExpr):
+    """Represents an operation to solve a linear matrix equation.
+    Parameters
+    ==========
+    matrix : MatrixSymbol
+      Matrix representing the coefficients of variables in the linear
+      equation. This matrix must be square and full-rank (i.e. all columns must
+      be linearly independent) for the solving operation to be valid.
+    vector : MatrixSymbol
+      One-column matrix representing the solutions to the equations
+      represented in ``matrix``.
+    Examples
+    ========
+    >>> from sympy import symbols, MatrixSymbol
+    >>> from sympy.codegen.matrix_nodes import MatrixSolve
+    >>> n = symbols('n', integer=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> x = MatrixSymbol('x', n, 1)
+    >>> from sympy.printing.numpy import NumPyPrinter
+    >>> NumPyPrinter().doprint(MatrixSolve(A, x))
+    'numpy.linalg.solve(A, x)'
+    >>> from sympy import octave_code
+    >>> octave_code(MatrixSolve(A, x))
+    'A \\\\ x'
+    """
+    __slots__ = _fields = ('matrix', 'vector')
+    _construct_matrix = staticmethod(sympify)
+    _construct_vector = staticmethod(sympify)
+    @property
+    def shape(self):
+        return self.vector.shape
+    def _eval_derivative(self, x):
+        A, b = self.matrix, self.vector
+        return MatrixSolve(A, b.diff(x) - A.diff(x) * MatrixSolve(A, b))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/pynodes.py ADDED Viewed

	@@ -0,0 +1,11 @@

+from .abstract_nodes import List as AbstractList
+from .ast import Token
+class List(AbstractList):
+    pass
+class NumExprEvaluate(Token):
+    """represents a call to :class:`numexpr`s :func:`evaluate`"""
+    __slots__ = _fields = ('expr',)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/scipy_nodes.py ADDED Viewed

	@@ -0,0 +1,79 @@

+from sympy.core.function import Add, ArgumentIndexError, Function
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import cos, sin
+def _cosm1(x, *, evaluate=True):
+    return Add(cos(x, evaluate=evaluate), -S.One, evaluate=evaluate)
+class cosm1(Function):
+    """ Minus one plus cosine of x, i.e. cos(x) - 1. For use when x is close to zero.
+    Helper class for use with e.g. scipy.special.cosm1
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.cosm1.html
+    """
+    nargs = 1
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return -sin(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+    def _eval_rewrite_as_cos(self, x, **kwargs):
+        return _cosm1(x)
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(cos).evalf(*args, **kwargs)
+    def _eval_simplify(self, **kwargs):
+        x, = self.args
+        candidate = _cosm1(x.simplify(**kwargs))
+        if candidate != _cosm1(x, evaluate=False):
+            return candidate
+        else:
+            return cosm1(x)
+def _powm1(x, y, *, evaluate=True):
+    return Add(Pow(x, y, evaluate=evaluate), -S.One, evaluate=evaluate)
+class powm1(Function):
+    """ Minus one plus x to the power of y, i.e. x**y - 1. For use when x is close to one or y is close to zero.
+    Helper class for use with e.g. scipy.special.powm1
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.powm1.html
+    """
+    nargs = 2
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], self.args[1])*self.args[1]/self.args[0]
+        elif argindex == 2:
+            return log(self.args[0])*Pow(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+    def _eval_rewrite_as_Pow(self, x, y, **kwargs):
+        return _powm1(x, y)
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(Pow).evalf(*args, **kwargs)
+    def _eval_simplify(self, **kwargs):
+        x, y = self.args
+        candidate = _powm1(x.simplify(**kwargs), y.simplify(**kwargs))
+        if candidate != _powm1(x, y, evaluate=False):
+            return candidate
+        else:
+            return powm1(x, y)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/combinatorics/tests/__pycache__/__init__.cpython-311.pyc ADDED Viewed

Binary file (226 Bytes). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/__pycache__/delta.cpython-311.pyc ADDED Viewed

Binary file (15.3 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/delta.py ADDED Viewed

	@@ -0,0 +1,330 @@

+"""
+This module implements sums and products containing the Kronecker Delta function.
+References
+==========
+.. [1] https://mathworld.wolfram.com/KroneckerDelta.html
+"""
+from .products import product
+from .summations import Sum, summation
+from sympy.core import Add, Mul, S, Dummy
+from sympy.core.cache import cacheit
+from sympy.core.sorting import default_sort_key
+from sympy.functions import KroneckerDelta, Piecewise, piecewise_fold
+from sympy.polys.polytools import factor
+from sympy.sets.sets import Interval
+from sympy.solvers.solvers import solve
+@cacheit
+def _expand_delta(expr, index):
+    """
+    Expand the first Add containing a simple KroneckerDelta.
+    """
+    if not expr.is_Mul:
+        return expr
+    delta = None
+    func = Add
+    terms = [S.One]
+    for h in expr.args:
+        if delta is None and h.is_Add and _has_simple_delta(h, index):
+            delta = True
+            func = h.func
+            terms = [terms[0]*t for t in h.args]
+        else:
+            terms = [t*h for t in terms]
+    return func(*terms)
+@cacheit
+def _extract_delta(expr, index):
+    """
+    Extract a simple KroneckerDelta from the expression.
+    Explanation
+    ===========
+    Returns the tuple ``(delta, newexpr)`` where:
+      - ``delta`` is a simple KroneckerDelta expression if one was found,
+        or ``None`` if no simple KroneckerDelta expression was found.
+      - ``newexpr`` is a Mul containing the remaining terms; ``expr`` is
+        returned unchanged if no simple KroneckerDelta expression was found.
+    Examples
+    ========
+    >>> from sympy import KroneckerDelta
+    >>> from sympy.concrete.delta import _extract_delta
+    >>> from sympy.abc import x, y, i, j, k
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), i)
+    (KroneckerDelta(i, j), 4*x*y)
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), k)
+    (None, 4*x*y*KroneckerDelta(i, j))
+    See Also
+    ========
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    deltaproduct
+    deltasummation
+    """
+    if not _has_simple_delta(expr, index):
+        return (None, expr)
+    if isinstance(expr, KroneckerDelta):
+        return (expr, S.One)
+    if not expr.is_Mul:
+        raise ValueError("Incorrect expr")
+    delta = None
+    terms = []
+    for arg in expr.args:
+        if delta is None and _is_simple_delta(arg, index):
+            delta = arg
+        else:
+            terms.append(arg)
+    return (delta, expr.func(*terms))
+@cacheit
+def _has_simple_delta(expr, index):
+    """
+    Returns True if ``expr`` is an expression that contains a KroneckerDelta
+    that is simple in the index ``index``, meaning that this KroneckerDelta
+    is nonzero for a single value of the index ``index``.
+    """
+    if expr.has(KroneckerDelta):
+        if _is_simple_delta(expr, index):
+            return True
+        if expr.is_Add or expr.is_Mul:
+            for arg in expr.args:
+                if _has_simple_delta(arg, index):
+                    return True
+    return False
+@cacheit
+def _is_simple_delta(delta, index):
+    """
+    Returns True if ``delta`` is a KroneckerDelta and is nonzero for a single
+    value of the index ``index``.
+    """
+    if isinstance(delta, KroneckerDelta) and delta.has(index):
+        p = (delta.args[0] - delta.args[1]).as_poly(index)
+        if p:
+            return p.degree() == 1
+    return False
+@cacheit
+def _remove_multiple_delta(expr):
+    """
+    Evaluate products of KroneckerDelta's.
+    """
+    if expr.is_Add:
+        return expr.func(*list(map(_remove_multiple_delta, expr.args)))
+    if not expr.is_Mul:
+        return expr
+    eqs = []
+    newargs = []
+    for arg in expr.args:
+        if isinstance(arg, KroneckerDelta):
+            eqs.append(arg.args[0] - arg.args[1])
+        else:
+            newargs.append(arg)
+    if not eqs:
+        return expr
+    solns = solve(eqs, dict=True)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) == 1:
+        for key in solns[0].keys():
+            newargs.append(KroneckerDelta(key, solns[0][key]))
+        expr2 = expr.func(*newargs)
+        if expr != expr2:
+            return _remove_multiple_delta(expr2)
+    return expr
+@cacheit
+def _simplify_delta(expr):
+    """
+    Rewrite a KroneckerDelta's indices in its simplest form.
+    """
+    if isinstance(expr, KroneckerDelta):
+        try:
+            slns = solve(expr.args[0] - expr.args[1], dict=True)
+            if slns and len(slns) == 1:
+                return Mul(*[KroneckerDelta(*(key, value))
+                            for key, value in slns[0].items()])
+        except NotImplementedError:
+            pass
+    return expr
+@cacheit
+def deltaproduct(f, limit):
+    """
+    Handle products containing a KroneckerDelta.
+    See Also
+    ========
+    deltasummation
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.products.product
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.One
+    if not f.has(KroneckerDelta):
+        return product(f, limit)
+    if f.is_Add:
+        # Identify the term in the Add that has a simple KroneckerDelta
+        delta = None
+        terms = []
+        for arg in sorted(f.args, key=default_sort_key):
+            if delta is None and _has_simple_delta(arg, limit[0]):
+                delta = arg
+            else:
+                terms.append(arg)
+        newexpr = f.func(*terms)
+        k = Dummy("kprime", integer=True)
+        if isinstance(limit[1], int) and isinstance(limit[2], int):
+            result = deltaproduct(newexpr, limit) + sum(deltaproduct(newexpr, (limit[0], limit[1], ik - 1)) *
+                delta.subs(limit[0], ik) *
+                deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))
+            )
+        else:
+            result = deltaproduct(newexpr, limit) + deltasummation(
+                deltaproduct(newexpr, (limit[0], limit[1], k - 1)) *
+                delta.subs(limit[0], k) *
+                deltaproduct(newexpr, (limit[0], k + 1, limit[2])),
+                (k, limit[1], limit[2]),
+                no_piecewise=_has_simple_delta(newexpr, limit[0])
+            )
+        return _remove_multiple_delta(result)
+    delta, _ = _extract_delta(f, limit[0])
+    if not delta:
+        g = _expand_delta(f, limit[0])
+        if f != g:
+            try:
+                return factor(deltaproduct(g, limit))
+            except AssertionError:
+                return deltaproduct(g, limit)
+        return product(f, limit)
+    return _remove_multiple_delta(f.subs(limit[0], limit[1])*KroneckerDelta(limit[2], limit[1])) + \
+        S.One*_simplify_delta(KroneckerDelta(limit[2], limit[1] - 1))
+@cacheit
+def deltasummation(f, limit, no_piecewise=False):
+    """
+    Handle summations containing a KroneckerDelta.
+    Explanation
+    ===========
+    The idea for summation is the following:
+    - If we are dealing with a KroneckerDelta expression, i.e. KroneckerDelta(g(x), j),
+      we try to simplify it.
+      If we could simplify it, then we sum the resulting expression.
+      We already know we can sum a simplified expression, because only
+      simple KroneckerDelta expressions are involved.
+      If we could not simplify it, there are two cases:
+      1) The expression is a simple expression: we return the summation,
+         taking care if we are dealing with a Derivative or with a proper
+         KroneckerDelta.
+      2) The expression is not simple (i.e. KroneckerDelta(cos(x))): we can do
+         nothing at all.
+    - If the expr is a multiplication expr having a KroneckerDelta term:
+      First we expand it.
+      If the expansion did work, then we try to sum the expansion.
+      If not, we try to extract a simple KroneckerDelta term, then we have two
+      cases:
+      1) We have a simple KroneckerDelta term, so we return the summation.
+      2) We did not have a simple term, but we do have an expression with
+         simplified KroneckerDelta terms, so we sum this expression.
+    Examples
+    ========
+    >>> from sympy import oo, symbols
+    >>> from sympy.abc import k
+    >>> i, j = symbols('i, j', integer=True, finite=True)
+    >>> from sympy.concrete.delta import deltasummation
+    >>> from sympy import KroneckerDelta
+    >>> deltasummation(KroneckerDelta(i, k), (k, -oo, oo))
+    1
+    >>> deltasummation(KroneckerDelta(i, k), (k, 0, oo))
+    Piecewise((1, i >= 0), (0, True))
+    >>> deltasummation(KroneckerDelta(i, k), (k, 1, 3))
+    Piecewise((1, (i >= 1) & (i <= 3)), (0, True))
+    >>> deltasummation(k*KroneckerDelta(i, j)*KroneckerDelta(j, k), (k, -oo, oo))
+    j*KroneckerDelta(i, j)
+    >>> deltasummation(j*KroneckerDelta(i, j), (j, -oo, oo))
+    i
+    >>> deltasummation(i*KroneckerDelta(i, j), (i, -oo, oo))
+    j
+    See Also
+    ========
+    deltaproduct
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.sums.summation
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.Zero
+    if not f.has(KroneckerDelta):
+        return summation(f, limit)
+    x = limit[0]
+    g = _expand_delta(f, x)
+    if g.is_Add:
+        return piecewise_fold(
+            g.func(*[deltasummation(h, limit, no_piecewise) for h in g.args]))
+    # try to extract a simple KroneckerDelta term
+    delta, expr = _extract_delta(g, x)
+    if (delta is not None) and (delta.delta_range is not None):
+        dinf, dsup = delta.delta_range
+        if (limit[1] - dinf <= 0) == True and (limit[2] - dsup >= 0) == True:
+            no_piecewise = True
+    if not delta:
+        return summation(f, limit)
+    solns = solve(delta.args[0] - delta.args[1], x)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) != 1:
+        return Sum(f, limit)
+    value = solns[0]
+    if no_piecewise:
+        return expr.subs(x, value)
+    return Piecewise(
+        (expr.subs(x, value), Interval(*limit[1:3]).as_relational(value)),
+        (S.Zero, True)
+    )

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/expr_with_intlimits.py ADDED Viewed

	@@ -0,0 +1,354 @@

+from sympy.concrete.expr_with_limits import ExprWithLimits
+from sympy.core.singleton import S
+from sympy.core.relational import Eq
+class ReorderError(NotImplementedError):
+    """
+    Exception raised when trying to reorder dependent limits.
+    """
+    def __init__(self, expr, msg):
+        super().__init__(
+            "%s could not be reordered: %s." % (expr, msg))
+class ExprWithIntLimits(ExprWithLimits):
+    """
+    Superclass for Product and Sum.
+    See Also
+    ========
+    sympy.concrete.expr_with_limits.ExprWithLimits
+    sympy.concrete.products.Product
+    sympy.concrete.summations.Sum
+    """
+    __slots__ = ()
+    def change_index(self, var, trafo, newvar=None):
+        r"""
+        Change index of a Sum or Product.
+        Perform a linear transformation `x \mapsto a x + b` on the index variable
+        `x`. For `a` the only values allowed are `\pm 1`. A new variable to be used
+        after the change of index can also be specified.
+        Explanation
+        ===========
+        ``change_index(expr, var, trafo, newvar=None)`` where ``var`` specifies the
+        index variable `x` to transform. The transformation ``trafo`` must be linear
+        and given in terms of ``var``. If the optional argument ``newvar`` is
+        provided then ``var`` gets replaced by ``newvar`` in the final expression.
+        Examples
+        ========
+        >>> from sympy import Sum, Product, simplify
+        >>> from sympy.abc import x, y, a, b, c, d, u, v, i, j, k, l
+        >>> S = Sum(x, (x, a, b))
+        >>> S.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+        >>> Sn = S.change_index(x, x + 1, y)
+        >>> Sn
+        Sum(y - 1, (y, a + 1, b + 1))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+        >>> Sn = S.change_index(x, -x, y)
+        >>> Sn
+        Sum(-y, (y, -b, -a))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+        >>> Sn = S.change_index(x, x+u)
+        >>> Sn
+        Sum(-u + x, (x, a + u, b + u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+        >>> Sn = S.change_index(x, -x - u, y)
+        >>> Sn
+        Sum(-u - y, (y, -b - u, -a - u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+        >>> P = Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P
+        Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P2 = P.change_index(i, i+3, k)
+        >>> P2
+        Product(j**2*(k - 3), (k, a + 3, b + 3), (j, c, d))
+        >>> P3 = P2.change_index(j, -j, l)
+        >>> P3
+        Product(l**2*(k - 3), (k, a + 3, b + 3), (l, -d, -c))
+        When dealing with symbols only, we can make a
+        general linear transformation:
+        >>> Sn = S.change_index(x, u*x+v, y)
+        >>> Sn
+        Sum((-v + y)/u, (y, b*u + v, a*u + v))
+        >>> Sn.doit()
+        -v*(a*u - b*u + 1)/u + (a**2*u**2/2 + a*u*v + a*u/2 - b**2*u**2/2 - b*u*v + b*u/2 + v)/u
+        >>> simplify(Sn.doit())
+        a**2*u/2 + a/2 - b**2*u/2 + b/2
+        However, the last result can be inconsistent with usual
+        summation where the index increment is always 1. This is
+        obvious as we get back the original value only for ``u``
+        equal +1 or -1.
+        See Also
+        ========
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder,
+        sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        if newvar is None:
+            newvar = var
+        limits = []
+        for limit in self.limits:
+            if limit[0] == var:
+                p = trafo.as_poly(var)
+                if p.degree() != 1:
+                    raise ValueError("Index transformation is not linear")
+                alpha = p.coeff_monomial(var)
+                beta = p.coeff_monomial(S.One)
+                if alpha.is_number:
+                    if alpha == S.One:
+                        limits.append((newvar, alpha*limit[1] + beta, alpha*limit[2] + beta))
+                    elif alpha == S.NegativeOne:
+                        limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+                    else:
+                        raise ValueError("Linear transformation results in non-linear summation stepsize")
+                else:
+                    # Note that the case of alpha being symbolic can give issues if alpha < 0.
+                    limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+            else:
+                limits.append(limit)
+        function = self.function.subs(var, (var - beta)/alpha)
+        function = function.subs(var, newvar)
+        return self.func(function, *limits)
+    def index(expr, x):
+        """
+        Return the index of a dummy variable in the list of limits.
+        Explanation
+        ===========
+        ``index(expr, x)``  returns the index of the dummy variable ``x`` in the
+        limits of ``expr``. Note that we start counting with 0 at the inner-most
+        limits tuple.
+        Examples
+        ========
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> from sympy import Sum, Product
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+        See Also
+        ========
+        reorder_limit, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        variables = [limit[0] for limit in expr.limits]
+        if variables.count(x) != 1:
+            raise ValueError(expr, "Number of instances of variable not equal to one")
+        else:
+            return variables.index(x)
+    def reorder(expr, *arg):
+        """
+        Reorder limits in a expression containing a Sum or a Product.
+        Explanation
+        ===========
+        ``expr.reorder(*arg)`` reorders the limits in the expression ``expr``
+        according to the list of tuples given by ``arg``. These tuples can
+        contain numerical indices or index variable names or involve both.
+        Examples
+        ========
+        >>> from sympy import Sum, Product
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((x, y))
+        Sum(x*y, (y, c, d), (x, a, b))
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder((x, y), (x, z), (y, z))
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        >>> P = Product(x*y*z, (x, a, b), (y, c, d), (z, e, f))
+        >>> P.reorder((x, y), (x, z), (y, z))
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        We can also select the index variables by counting them, starting
+        with the inner-most one:
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder((0, 1))
+        Sum(x**2, (x, c, d), (x, a, b))
+        And of course we can mix both schemes:
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x))
+        Sum(x*y, (y, c, d), (x, a, b))
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, 0))
+        Sum(x*y, (y, c, d), (x, a, b))
+        See Also
+        ========
+        reorder_limit, index, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        new_expr = expr
+        for r in arg:
+            if len(r) != 2:
+                raise ValueError(r, "Invalid number of arguments")
+            index1 = r[0]
+            index2 = r[1]
+            if not isinstance(r[0], int):
+                index1 = expr.index(r[0])
+            if not isinstance(r[1], int):
+                index2 = expr.index(r[1])
+            new_expr = new_expr.reorder_limit(index1, index2)
+        return new_expr
+    def reorder_limit(expr, x, y):
+        """
+        Interchange two limit tuples of a Sum or Product expression.
+        Explanation
+        ===========
+        ``expr.reorder_limit(x, y)`` interchanges two limit tuples. The
+        arguments ``x`` and ``y`` are integers corresponding to the index
+        variables of the two limits which are to be interchanged. The
+        expression ``expr`` has to be either a Sum or a Product.
+        Examples
+        ========
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+        >>> from sympy import Sum, Product
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder_limit(1, 0)
+        Sum(x**2, (x, c, d), (x, a, b))
+        >>> Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        See Also
+        ========
+        index, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        var = {limit[0] for limit in expr.limits}
+        limit_x = expr.limits[x]
+        limit_y = expr.limits[y]
+        if (len(set(limit_x[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_x[2].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[2].free_symbols).intersection(var)) == 0):
+            limits = []
+            for i, limit in enumerate(expr.limits):
+                if i == x:
+                    limits.append(limit_y)
+                elif i == y:
+                    limits.append(limit_x)
+                else:
+                    limits.append(limit)
+            return type(expr)(expr.function, *limits)
+        else:
+            raise ReorderError(expr, "could not interchange the two limits specified")
+    @property
+    def has_empty_sequence(self):
+        """
+        Returns True if the Sum or Product is computed for an empty sequence.
+        Examples
+        ========
+        >>> from sympy import Sum, Product, Symbol
+        >>> m = Symbol('m')
+        >>> Sum(m, (m, 1, 0)).has_empty_sequence
+        True
+        >>> Sum(m, (m, 1, 1)).has_empty_sequence
+        False
+        >>> M = Symbol('M', integer=True, positive=True)
+        >>> Product(m, (m, 1, M)).has_empty_sequence
+        False
+        >>> Product(m, (m, 2, M)).has_empty_sequence
+        >>> Product(m, (m, M + 1, M)).has_empty_sequence
+        True
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+        >>> N = Symbol('N', integer=True, negative=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+        False
+        See Also
+        ========
+        has_reversed_limits
+        has_finite_limits
+        """
+        ret_None = False
+        for lim in self.limits:
+            dif = lim[1] - lim[2]
+            eq = Eq(dif, 1)
+            if eq == True:
+                return True
+            elif eq == False:
+                continue
+            else:
+                ret_None = True
+        if ret_None:
+            return None
+        return False

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/expr_with_limits.py ADDED Viewed

	@@ -0,0 +1,603 @@

+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import AppliedUndef, UndefinedFunction
+from sympy.core.mul import Mul
+from sympy.core.relational import Equality, Relational
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import (piecewise_fold,
+    Piecewise)
+from sympy.logic.boolalg import BooleanFunction
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.sets.sets import Interval, Set
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import Idx
+from sympy.utilities import flatten
+from sympy.utilities.iterables import sift, is_sequence
+from sympy.utilities.exceptions import sympy_deprecation_warning
+def _common_new(cls, function, *symbols, discrete, **assumptions):
+    """Return either a special return value or the tuple,
+    (function, limits, orientation). This code is common to
+    both ExprWithLimits and AddWithLimits."""
+    function = sympify(function)
+    if isinstance(function, Equality):
+        # This transforms e.g. Integral(Eq(x, y)) to Eq(Integral(x), Integral(y))
+        # but that is only valid for definite integrals.
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        if not (limits and all(len(limit) == 3 for limit in limits)):
+            sympy_deprecation_warning(
+                """
+                Creating a indefinite integral with an Eq() argument is
+                deprecated.
+                This is because indefinite integrals do not preserve equality
+                due to the arbitrary constants. If you want an equality of
+                indefinite integrals, use Eq(Integral(a, x), Integral(b, x))
+                explicitly.
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-indefinite-integral-eq",
+                stacklevel=5,
+            )
+        lhs = function.lhs
+        rhs = function.rhs
+        return Equality(cls(lhs, *symbols, **assumptions), \
+                        cls(rhs, *symbols, **assumptions))
+    if function is S.NaN:
+        return S.NaN
+    if symbols:
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        for i, li in enumerate(limits):
+            if len(li) == 4:
+                function = function.subs(li[0], li[-1])
+                limits[i] = Tuple(*li[:-1])
+    else:
+        # symbol not provided -- we can still try to compute a general form
+        free = function.free_symbols
+        if len(free) != 1:
+            raise ValueError(
+                "specify dummy variables for %s" % function)
+        limits, orientation = [Tuple(s) for s in free], 1
+    # denest any nested calls
+    while cls == type(function):
+        limits = list(function.limits) + limits
+        function = function.function
+    # Any embedded piecewise functions need to be brought out to the
+    # top level. We only fold Piecewise that contain the integration
+    # variable.
+    reps = {}
+    symbols_of_integration = {i[0] for i in limits}
+    for p in function.atoms(Piecewise):
+        if not p.has(*symbols_of_integration):
+            reps[p] = Dummy()
+    # mask off those that don't
+    function = function.xreplace(reps)
+    # do the fold
+    function = piecewise_fold(function)
+    # remove the masking
+    function = function.xreplace({v: k for k, v in reps.items()})
+    return function, limits, orientation
+def _process_limits(*symbols, discrete=None):
+    """Process the list of symbols and convert them to canonical limits,
+    storing them as Tuple(symbol, lower, upper). The orientation of
+    the function is also returned when the upper limit is missing
+    so (x, 1, None) becomes (x, None, 1) and the orientation is changed.
+    In the case that a limit is specified as (symbol, Range), a list of
+    length 4 may be returned if a change of variables is needed; the
+    expression that should replace the symbol in the expression is
+    the fourth element in the list.
+    """
+    limits = []
+    orientation = 1
+    if discrete is None:
+        err_msg = 'discrete must be True or False'
+    elif discrete:
+        err_msg = 'use Range, not Interval or Relational'
+    else:
+        err_msg = 'use Interval or Relational, not Range'
+    for V in symbols:
+        if isinstance(V, (Relational, BooleanFunction)):
+            if discrete:
+                raise TypeError(err_msg)
+            variable = V.atoms(Symbol).pop()
+            V = (variable, V.as_set())
+        elif isinstance(V, Symbol) or getattr(V, '_diff_wrt', False):
+            if isinstance(V, Idx):
+                if V.lower is None or V.upper is None:
+                    limits.append(Tuple(V))
+                else:
+                    limits.append(Tuple(V, V.lower, V.upper))
+            else:
+                limits.append(Tuple(V))
+            continue
+        if is_sequence(V) and not isinstance(V, Set):
+            if len(V) == 2 and isinstance(V[1], Set):
+                V = list(V)
+                if isinstance(V[1], Interval):  # includes Reals
+                    if discrete:
+                        raise TypeError(err_msg)
+                    V[1:] = V[1].inf, V[1].sup
+                elif isinstance(V[1], Range):
+                    if not discrete:
+                        raise TypeError(err_msg)
+                    lo = V[1].inf
+                    hi = V[1].sup
+                    dx = abs(V[1].step)  # direction doesn't matter
+                    if dx == 1:
+                        V[1:] = [lo, hi]
+                    else:
+                        if lo is not S.NegativeInfinity:
+                            V = [V[0]] + [0, (hi - lo)//dx, dx*V[0] + lo]
+                        else:
+                            V = [V[0]] + [0, S.Infinity, -dx*V[0] + hi]
+                else:
+                    # more complicated sets would require splitting, e.g.
+                    # Union(Interval(1, 3), interval(6,10))
+                    raise NotImplementedError(
+                        'expecting Range' if discrete else
+                        'Relational or single Interval' )
+            V = sympify(flatten(V))  # list of sympified elements/None
+            if isinstance(V[0], (Symbol, Idx)) or getattr(V[0], '_diff_wrt', False):
+                newsymbol = V[0]
+                if len(V) == 3:
+                    # general case
+                    if V[2] is None and V[1] is not None:
+                        orientation *= -1
+                    V = [newsymbol] + [i for i in V[1:] if i is not None]
+                lenV = len(V)
+                if not isinstance(newsymbol, Idx) or lenV == 3:
+                    if lenV == 4:
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 3:
+                        if isinstance(newsymbol, Idx):
+                            # Idx represents an integer which may have
+                            # specified values it can take on; if it is
+                            # given such a value, an error is raised here
+                            # if the summation would try to give it a larger
+                            # or smaller value than permitted. None and Symbolic
+                            # values will not raise an error.
+                            lo, hi = newsymbol.lower, newsymbol.upper
+                            try:
+                                if lo is not None and not bool(V[1] >= lo):
+                                    raise ValueError("Summation will set Idx value too low.")
+                            except TypeError:
+                                pass
+                            try:
+                                if hi is not None and not bool(V[2] <= hi):
+                                    raise ValueError("Summation will set Idx value too high.")
+                            except TypeError:
+                                pass
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 1 or (lenV == 2 and V[1] is None):
+                        limits.append(Tuple(newsymbol))
+                        continue
+                    elif lenV == 2:
+                        limits.append(Tuple(newsymbol, V[1]))
+                        continue
+        raise ValueError('Invalid limits given: %s' % str(symbols))
+    return limits, orientation
+class ExprWithLimits(Expr):
+    __slots__ = ('is_commutative',)
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.products import Product
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Product), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, _ = pre
+        else:
+            return pre
+        # limits must have upper and lower bounds; the indefinite form
+        # is not supported. This restriction does not apply to AddWithLimits
+        if any(len(l) != 3 or None in l for l in limits):
+            raise ValueError('ExprWithLimits requires values for lower and upper bounds.')
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [function]
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+        return obj
+    @property
+    def function(self):
+        """Return the function applied across limits.
+        Examples
+        ========
+        >>> from sympy import Integral
+        >>> from sympy.abc import x
+        >>> Integral(x**2, (x,)).function
+        x**2
+        See Also
+        ========
+        limits, variables, free_symbols
+        """
+        return self._args[0]
+    @property
+    def kind(self):
+        return self.function.kind
+    @property
+    def limits(self):
+        """Return the limits of expression.
+        Examples
+        ========
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i
+        >>> Integral(x**i, (i, 1, 3)).limits
+        ((i, 1, 3),)
+        See Also
+        ========
+        function, variables, free_symbols
+        """
+        return self._args[1:]
+    @property
+    def variables(self):
+        """Return a list of the limit variables.
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, i
+        >>> Sum(x**i, (i, 1, 3)).variables
+        [i]
+        See Also
+        ========
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits]
+    @property
+    def bound_symbols(self):
+        """Return only variables that are dummy variables.
+        Examples
+        ========
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i, j, k
+        >>> Integral(x**i, (i, 1, 3), (j, 2), k).bound_symbols
+        [i, j]
+        See Also
+        ========
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits if len(l) != 1]
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols in the object, excluding those
+        that take on a specific value (i.e. the dummy symbols).
+        Examples
+        ========
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y
+        >>> Sum(x, (x, y, 1)).free_symbols
+        {y}
+        """
+        # don't test for any special values -- nominal free symbols
+        # should be returned, e.g. don't return set() if the
+        # function is zero -- treat it like an unevaluated expression.
+        function, limits = self.function, self.limits
+        # mask off non-symbol integration variables that have
+        # more than themself as a free symbol
+        reps = {i[0]: i[0] if i[0].free_symbols == {i[0]} else Dummy()
+            for i in self.limits}
+        function = function.xreplace(reps)
+        isyms = function.free_symbols
+        for xab in limits:
+            v = reps[xab[0]]
+            if len(xab) == 1:
+                isyms.add(v)
+                continue
+            # take out the target symbol
+            if v in isyms:
+                isyms.remove(v)
+            # add in the new symbols
+            for i in xab[1:]:
+                isyms.update(i.free_symbols)
+        reps = {v: k for k, v in reps.items()}
+        return {reps.get(_, _) for _ in isyms}
+    @property
+    def is_number(self):
+        """Return True if the Sum has no free symbols, else False."""
+        return not self.free_symbols
+    def _eval_interval(self, x, a, b):
+        limits = [(i if i[0] != x else (x, a, b)) for i in self.limits]
+        integrand = self.function
+        return self.func(integrand, *limits)
+    def _eval_subs(self, old, new):
+        """
+        Perform substitutions over non-dummy variables
+        of an expression with limits.  Also, can be used
+        to specify point-evaluation of an abstract antiderivative.
+        Examples
+        ========
+        >>> from sympy import Sum, oo
+        >>> from sympy.abc import s, n
+        >>> Sum(1/n**s, (n, 1, oo)).subs(s, 2)
+        Sum(n**(-2), (n, 1, oo))
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, a
+        >>> Integral(a*x**2, x).subs(x, 4)
+        Integral(a*x**2, (x, 4))
+        See Also
+        ========
+        variables : Lists the integration variables
+        transform : Perform mapping on the dummy variable for integrals
+        change_index : Perform mapping on the sum and product dummy variables
+        """
+        func, limits = self.function, list(self.limits)
+        # If one of the expressions we are replacing is used as a func index
+        # one of two things happens.
+        #   - the old variable first appears as a free variable
+        #     so we perform all free substitutions before it becomes
+        #     a func index.
+        #   - the old variable first appears as a func index, in
+        #     which case we ignore.  See change_index.
+        # Reorder limits to match standard mathematical practice for scoping
+        limits.reverse()
+        if not isinstance(old, Symbol) or \
+                old.free_symbols.intersection(self.free_symbols):
+            sub_into_func = True
+            for i, xab in enumerate(limits):
+                if 1 == len(xab) and old == xab[0]:
+                    if new._diff_wrt:
+                        xab = (new,)
+                    else:
+                        xab = (old, old)
+                limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                if len(xab[0].free_symbols.intersection(old.free_symbols)) != 0:
+                    sub_into_func = False
+                    break
+            if isinstance(old, (AppliedUndef, UndefinedFunction)):
+                sy2 = set(self.variables).intersection(set(new.atoms(Symbol)))
+                sy1 = set(self.variables).intersection(set(old.args))
+                if not sy2.issubset(sy1):
+                    raise ValueError(
+                        "substitution cannot create dummy dependencies")
+                sub_into_func = True
+            if sub_into_func:
+                func = func.subs(old, new)
+        else:
+            # old is a Symbol and a dummy variable of some limit
+            for i, xab in enumerate(limits):
+                if len(xab) == 3:
+                    limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                    if old == xab[0]:
+                        break
+        # simplify redundant limits (x, x)  to (x, )
+        for i, xab in enumerate(limits):
+            if len(xab) == 2 and (xab[0] - xab[1]).is_zero:
+                limits[i] = Tuple(xab[0], )
+        # Reorder limits back to representation-form
+        limits.reverse()
+        return self.func(func, *limits)
+    @property
+    def has_finite_limits(self):
+        """
+        Returns True if the limits are known to be finite, either by the
+        explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be infinite, based on the bounds.
+        None if not enough information is available to determine.
+        Examples
+        ========
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 1, 8)).has_finite_limits
+        True
+        >>> Integral(x, (x, 1, oo)).has_finite_limits
+        False
+        >>> M = Symbol('M')
+        >>> Sum(x, (x, 1, M)).has_finite_limits
+        >>> N = Symbol('N', integer=True)
+        >>> Product(x, (x, 1, N)).has_finite_limits
+        True
+        See Also
+        ========
+        has_reversed_limits
+        """
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                if any(l.is_infinite for l in lim[1:]):
+                    # Any of the bounds are +/-oo
+                    return False
+                elif any(l.is_infinite is None for l in lim[1:]):
+                    # Maybe there are assumptions on the variable?
+                    if lim[0].is_infinite is None:
+                        ret_None = True
+            else:
+                if lim[0].is_infinite is None:
+                    ret_None = True
+        if ret_None:
+            return None
+        return True
+    @property
+    def has_reversed_limits(self):
+        """
+        Returns True if the limits are known to be in reversed order, either
+        by the explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be in normal order, based on the bounds.
+        None if not enough information is available to determine.
+        Examples
+        ========
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 8, 1)).has_reversed_limits
+        True
+        >>> Sum(x, (x, 1, oo)).has_reversed_limits
+        False
+        >>> M = Symbol('M')
+        >>> Integral(x, (x, 1, M)).has_reversed_limits
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(x, (x, 1, N)).has_reversed_limits
+        False
+        >>> Product(x, (x, 2, N)).has_reversed_limits
+        >>> Product(x, (x, 2, N)).subs(N, N + 2).has_reversed_limits
+        False
+        See Also
+        ========
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.has_empty_sequence
+        """
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                var, a, b = lim
+                dif = b - a
+                if dif.is_extended_negative:
+                    return True
+                elif dif.is_extended_nonnegative:
+                    continue
+                else:
+                    ret_None = True
+            else:
+                return None
+        if ret_None:
+            return None
+        return False
+class AddWithLimits(ExprWithLimits):
+    r"""Represents unevaluated oriented additions.
+        Parent class for Integral and Sum.
+    """
+    __slots__ = ()
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.summations import Sum
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Sum), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, orientation = pre
+        else:
+            return pre
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [orientation*function]  # orientation not used in ExprWithLimits
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+        return obj
+    def _eval_adjoint(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.adjoint(), *self.limits)
+        return None
+    def _eval_conjugate(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.conjugate(), *self.limits)
+        return None
+    def _eval_transpose(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+    def _eval_factor(self, **hints):
+        if 1 == len(self.limits):
+            summand = self.function.factor(**hints)
+            if summand.is_Mul:
+                out = sift(summand.args, lambda w: w.is_commutative \
+                    and not set(self.variables) & w.free_symbols)
+                return Mul(*out[True])*self.func(Mul(*out[False]), \
+                    *self.limits)
+        else:
+            summand = self.func(self.function, *self.limits[0:-1]).factor()
+            if not summand.has(self.variables[-1]):
+                return self.func(1, [self.limits[-1]]).doit()*summand
+            elif isinstance(summand, Mul):
+                return self.func(summand, self.limits[-1]).factor()
+        return self
+    def _eval_expand_basic(self, **hints):
+        summand = self.function.expand(**hints)
+        force = hints.get('force', False)
+        if (summand.is_Add and (force or summand.is_commutative and
+                 self.has_finite_limits is not False)):
+            return Add(*[self.func(i, *self.limits) for i in summand.args])
+        elif isinstance(summand, MatrixBase):
+            return summand.applyfunc(lambda x: self.func(x, *self.limits))
+        elif summand != self.function:
+            return self.func(summand, *self.limits)
+        return self

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/products.py ADDED Viewed

	@@ -0,0 +1,610 @@

+from typing import Tuple as tTuple
+from .expr_with_intlimits import ExprWithIntLimits
+from .summations import Sum, summation, _dummy_with_inherited_properties_concrete
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Derivative
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol
+from sympy.functions.combinatorial.factorials import RisingFactorial
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.polys import quo, roots
+class Product(ExprWithIntLimits):
+    r"""
+    Represents unevaluated products.
+    Explanation
+    ===========
+    ``Product`` represents a finite or infinite product, with the first
+    argument being the general form of terms in the series, and the second
+    argument being ``(dummy_variable, start, end)``, with ``dummy_variable``
+    taking all integer values from ``start`` through ``end``. In accordance
+    with long-standing mathematical convention, the end term is included in
+    the product.
+    Finite products
+    ===============
+    For finite products (and products with symbolic limits assumed to be finite)
+    we follow the analogue of the summation convention described by Karr [1],
+    especially definition 3 of section 1.4. The product:
+    .. math::
+        \prod_{m \leq i < n} f(i)
+    has *the obvious meaning* for `m < n`, namely:
+    .. math::
+        \prod_{m \leq i < n} f(i) = f(m) f(m+1) \cdot \ldots \cdot f(n-2) f(n-1)
+    with the upper limit value `f(n)` excluded. The product over an empty set is
+    one if and only if `m = n`:
+    .. math::
+        \prod_{m \leq i < n} f(i) = 1  \quad \mathrm{for} \quad  m = n
+    Finally, for all other products over empty sets we assume the following
+    definition:
+    .. math::
+        \prod_{m \leq i < n} f(i) = \frac{1}{\prod_{n \leq i < m} f(i)}  \quad \mathrm{for} \quad  m > n
+    It is important to note that above we define all products with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the product convention. Indeed we have:
+    .. math::
+        \prod_{m \leq i < n} f(i) = \prod_{i = m}^{n - 1} f(i)
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+    Examples
+    ========
+    >>> from sympy.abc import a, b, i, k, m, n, x
+    >>> from sympy import Product, oo
+    >>> Product(k, (k, 1, m))
+    Product(k, (k, 1, m))
+    >>> Product(k, (k, 1, m)).doit()
+    factorial(m)
+    >>> Product(k**2,(k, 1, m))
+    Product(k**2, (k, 1, m))
+    >>> Product(k**2,(k, 1, m)).doit()
+    factorial(m)**2
+    Wallis' product for pi:
+    >>> W = Product(2*i/(2*i-1) * 2*i/(2*i+1), (i, 1, oo))
+    >>> W
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+    Direct computation currently fails:
+    >>> W.doit()
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+    But we can approach the infinite product by a limit of finite products:
+    >>> from sympy import limit
+    >>> W2 = Product(2*i/(2*i-1)*2*i/(2*i+1), (i, 1, n))
+    >>> W2
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, n))
+    >>> W2e = W2.doit()
+    >>> W2e
+    4**n*factorial(n)**2/(2**(2*n)*RisingFactorial(1/2, n)*RisingFactorial(3/2, n))
+    >>> limit(W2e, n, oo)
+    pi/2
+    By the same formula we can compute sin(pi/2):
+    >>> from sympy import combsimp, pi, gamma, simplify
+    >>> P = pi * x * Product(1 - x**2/k**2, (k, 1, n))
+    >>> P = P.subs(x, pi/2)
+    >>> P
+    pi**2*Product(1 - pi**2/(4*k**2), (k, 1, n))/2
+    >>> Pe = P.doit()
+    >>> Pe
+    pi**2*RisingFactorial(1 - pi/2, n)*RisingFactorial(1 + pi/2, n)/(2*factorial(n)**2)
+    >>> limit(Pe, n, oo).gammasimp()
+    sin(pi**2/2)
+    >>> Pe.rewrite(gamma)
+    (-1)**n*pi**2*gamma(pi/2)*gamma(n + 1 + pi/2)/(2*gamma(1 + pi/2)*gamma(-n + pi/2)*gamma(n + 1)**2)
+    Products with the lower limit being larger than the upper one:
+    >>> Product(1/i, (i, 6, 1)).doit()
+    120
+    >>> Product(i, (i, 2, 5)).doit()
+    120
+    The empty product:
+    >>> Product(i, (i, n, n-1)).doit()
+    1
+    An example showing that the symbolic result of a product is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those products by interchanging the limits according to the above rules:
+    >>> P = Product(2, (i, 10, n)).doit()
+    >>> P
+    2**(n - 9)
+    >>> P.subs(n, 5)
+    1/16
+    >>> Product(2, (i, 10, 5)).doit()
+    1/16
+    >>> 1/Product(2, (i, 6, 9)).doit()
+    1/16
+    An explicit example of the Karr summation convention applied to products:
+    >>> P1 = Product(x, (i, a, b)).doit()
+    >>> P1
+    x**(-a + b + 1)
+    >>> P2 = Product(x, (i, b+1, a-1)).doit()
+    >>> P2
+    x**(a - b - 1)
+    >>> simplify(P1 * P2)
+    1
+    And another one:
+    >>> P1 = Product(i, (i, b, a)).doit()
+    >>> P1
+    RisingFactorial(b, a - b + 1)
+    >>> P2 = Product(i, (i, a+1, b-1)).doit()
+    >>> P2
+    RisingFactorial(a + 1, -a + b - 1)
+    >>> P1 * P2
+    RisingFactorial(b, a - b + 1)*RisingFactorial(a + 1, -a + b - 1)
+    >>> combsimp(P1 * P2)
+    1
+    See Also
+    ========
+    Sum, summation
+    product
+    References
+    ==========
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Multiplication#Capital_Pi_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_product
+    """
+    __slots__ = ()
+    limits: tTuple[tTuple[Symbol, Expr, Expr]]
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = ExprWithIntLimits.__new__(cls, function, *symbols, **assumptions)
+        return obj
+    def _eval_rewrite_as_Sum(self, *args, **kwargs):
+        return exp(Sum(log(self.function), *self.limits))
+    @property
+    def term(self):
+        return self._args[0]
+    function = term
+    def _eval_is_zero(self):
+        if self.has_empty_sequence:
+            return False
+        z = self.term.is_zero
+        if z is True:
+            return True
+        if self.has_finite_limits:
+            # A Product is zero only if its term is zero assuming finite limits.
+            return z
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+        return self.function.is_extended_real
+    def _eval_is_positive(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_positive and self.has_finite_limits:
+            return True
+    def _eval_is_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_nonnegative and self.has_finite_limits:
+            return True
+    def _eval_is_extended_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_extended_nonnegative:
+            return True
+    def _eval_is_extended_nonpositive(self):
+        if self.has_empty_sequence:
+            return True
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+    def doit(self, **hints):
+        # first make sure any definite limits have product
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            else:
+                did = did.xreplace(undo)
+            return did
+        from sympy.simplify.powsimp import powsimp
+        f = self.function
+        for index, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = 1 / f
+            g = self._eval_product(f, (i, a, b))
+            if g in (None, S.NaN):
+                return self.func(powsimp(f), *self.limits[index:])
+            else:
+                f = g
+        if hints.get('deep', True):
+            return f.doit(**hints)
+        else:
+            return powsimp(f)
+    def _eval_adjoint(self):
+        if self.is_commutative:
+            return self.func(self.function.adjoint(), *self.limits)
+        return None
+    def _eval_conjugate(self):
+        return self.func(self.function.conjugate(), *self.limits)
+    def _eval_product(self, term, limits):
+        (k, a, n) = limits
+        if k not in term.free_symbols:
+            if (term - 1).is_zero:
+                return S.One
+            return term**(n - a + 1)
+        if a == n:
+            return term.subs(k, a)
+        from .delta import deltaproduct, _has_simple_delta
+        if term.has(KroneckerDelta) and _has_simple_delta(term, limits[0]):
+            return deltaproduct(term, limits)
+        dif = n - a
+        definite = dif.is_Integer
+        if definite and (dif < 100):
+            return self._eval_product_direct(term, limits)
+        elif term.is_polynomial(k):
+            poly = term.as_poly(k)
+            A = B = Q = S.One
+            all_roots = roots(poly)
+            M = 0
+            for r, m in all_roots.items():
+                M += m
+                A *= RisingFactorial(a - r, n - a + 1)**m
+                Q *= (n - r)**m
+            if M < poly.degree():
+                arg = quo(poly, Q.as_poly(k))
+                B = self.func(arg, (k, a, n)).doit()
+            return poly.LC()**(n - a + 1) * A * B
+        elif term.is_Add:
+            factored = factor_terms(term, fraction=True)
+            if factored.is_Mul:
+                return self._eval_product(factored, (k, a, n))
+        elif term.is_Mul:
+            # Factor in part without the summation variable and part with
+            without_k, with_k = term.as_coeff_mul(k)
+            if len(with_k) >= 2:
+                # More than one term including k, so still a multiplication
+                exclude, include = [], []
+                for t in with_k:
+                    p = self._eval_product(t, (k, a, n))
+                    if p is not None:
+                        exclude.append(p)
+                    else:
+                        include.append(t)
+                if not exclude:
+                    return None
+                else:
+                    arg = term._new_rawargs(*include)
+                    A = Mul(*exclude)
+                    B = self.func(arg, (k, a, n)).doit()
+                    return without_k**(n - a + 1)*A * B
+            else:
+                # Just a single term
+                p = self._eval_product(with_k[0], (k, a, n))
+                if p is None:
+                    p = self.func(with_k[0], (k, a, n)).doit()
+                return without_k**(n - a + 1)*p
+        elif term.is_Pow:
+            if not term.base.has(k):
+                s = summation(term.exp, (k, a, n))
+                return term.base**s
+            elif not term.exp.has(k):
+                p = self._eval_product(term.base, (k, a, n))
+                if p is not None:
+                    return p**term.exp
+        elif isinstance(term, Product):
+            evaluated = term.doit()
+            f = self._eval_product(evaluated, limits)
+            if f is None:
+                return self.func(evaluated, limits)
+            else:
+                return f
+        if definite:
+            return self._eval_product_direct(term, limits)
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import product_simplify
+        rv = product_simplify(self, **kwargs)
+        return rv.doit() if kwargs['doit'] else rv
+    def _eval_transpose(self):
+        if self.is_commutative:
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+    def _eval_product_direct(self, term, limits):
+        (k, a, n) = limits
+        return Mul(*[term.subs(k, a + i) for i in range(n - a + 1)])
+    def _eval_derivative(self, x):
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+        f, limits = self.function, list(self.limits)
+        limit = limits.pop(-1)
+        if limits:
+            f = self.func(f, *limits)
+        i, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        h = Dummy()
+        rv = Sum( Product(f, (i, a, h - 1)) * Product(f, (i, h + 1, b)) * Derivative(f, x, evaluate=True).subs(i, h), (h, a, b))
+        return rv
+    def is_convergent(self):
+        r"""
+        See docs of :obj:`.Sum.is_convergent()` for explanation of convergence
+        in SymPy.
+        Explanation
+        ===========
+        The infinite product:
+        .. math::
+            \prod_{1 \leq i < \infty} f(i)
+        is defined by the sequence of partial products:
+        .. math::
+            \prod_{i=1}^{n} f(i) = f(1) f(2) \cdots f(n)
+        as n increases without bound. The product converges to a non-zero
+        value if and only if the sum:
+        .. math::
+            \sum_{1 \leq i < \infty} \log{f(n)}
+        converges.
+        Examples
+        ========
+        >>> from sympy import Product, Symbol, cos, pi, exp, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Product(n/(n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Product(1/n**2, (n, 1, oo)).is_convergent()
+        False
+        >>> Product(cos(pi/n), (n, 1, oo)).is_convergent()
+        True
+        >>> Product(exp(-n**2), (n, 1, oo)).is_convergent()
+        False
+        References
+        ==========
+        .. [1] https://en.wikipedia.org/wiki/Infinite_product
+        """
+        sequence_term = self.function
+        log_sum = log(sequence_term)
+        lim = self.limits
+        try:
+            is_conv = Sum(log_sum, *lim).is_convergent()
+        except NotImplementedError:
+            if Sum(sequence_term - 1, *lim).is_absolutely_convergent() is S.true:
+                return S.true
+            raise NotImplementedError("The algorithm to find the product convergence of %s "
+                                        "is not yet implemented" % (sequence_term))
+        return is_conv
+    def reverse_order(expr, *indices):
+        """
+        Reverse the order of a limit in a Product.
+        Explanation
+        ===========
+        ``reverse_order(expr, *indices)`` reverses some limits in the expression
+        ``expr`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+        Examples
+        ========
+        >>> from sympy import gamma, Product, simplify, Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> P = Product(x, (x, a, b))
+        >>> Pr = P.reverse_order(x)
+        >>> Pr
+        Product(1/x, (x, b + 1, a - 1))
+        >>> Pr = Pr.doit()
+        >>> Pr
+        1/RisingFactorial(b + 1, a - b - 1)
+        >>> simplify(Pr.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), b > -1), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+        >>> P = P.doit()
+        >>> P
+        RisingFactorial(a, -a + b + 1)
+        >>> simplify(P.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), a > 0), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+        >>> S = Sum(x*y, (x, a, b), (y, c, d))
+        >>> S
+        Sum(x*y, (x, a, b), (y, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x*y, (x, b + 1, a - 1), (y, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x*y, (x, b + 1, a - 1), (y, d + 1, c - 1))
+        Of course we can mix both notations:
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        See Also
+        ========
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+        References
+        ==========
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+        """
+        l_indices = list(indices)
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = expr.index(indx)
+        e = 1
+        limits = []
+        for i, limit in enumerate(expr.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+        return Product(expr.function ** e, *limits)
+def product(*args, **kwargs):
+    r"""
+    Compute the product.
+    Explanation
+    ===========
+    The notation for symbols is similar to the notation used in Sum or
+    Integral. product(f, (i, a, b)) computes the product of f with
+    respect to i from a to b, i.e.,
+    ::
+                                     b
+                                   _____
+        product(f(n), (i, a, b)) = |   | f(n)
+                                   |   |
+                                   i = a
+    If it cannot compute the product, it returns an unevaluated Product object.
+    Repeated products can be computed by introducing additional symbols tuples::
+    Examples
+    ========
+    >>> from sympy import product, symbols
+    >>> i, n, m, k = symbols('i n m k', integer=True)
+    >>> product(i, (i, 1, k))
+    factorial(k)
+    >>> product(m, (i, 1, k))
+    m**k
+    >>> product(i, (i, 1, k), (k, 1, n))
+    Product(factorial(k), (k, 1, n))
+    """
+    prod = Product(*args, **kwargs)
+    if isinstance(prod, Product):
+        return prod.doit(deep=False)
+    else:
+        return prod

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/summations.py ADDED Viewed

	@@ -0,0 +1,1646 @@

+from typing import Tuple as tTuple
+from sympy.calculus.singularities import is_decreasing
+from sympy.calculus.accumulationbounds import AccumulationBounds
+from .expr_with_intlimits import ExprWithIntLimits
+from .expr_with_limits import AddWithLimits
+from .gosper import gosper_sum
+from sympy.core.expr import Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import Derivative, expand
+from sympy.core.mul import Mul
+from sympy.core.numbers import Float, _illegal
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, Wild, Symbol, symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cot, csc
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.polys.partfrac import apart
+from sympy.polys.polyerrors import PolynomialError, PolificationFailed
+from sympy.polys.polytools import parallel_poly_from_expr, Poly, factor
+from sympy.polys.rationaltools import together
+from sympy.series.limitseq import limit_seq
+from sympy.series.order import O
+from sympy.series.residues import residue
+from sympy.sets.sets import FiniteSet, Interval
+from sympy.utilities.iterables import sift
+import itertools
+class Sum(AddWithLimits, ExprWithIntLimits):
+    r"""
+    Represents unevaluated summation.
+    Explanation
+    ===========
+    ``Sum`` represents a finite or infinite series, with the first argument
+    being the general form of terms in the series, and the second argument
+    being ``(dummy_variable, start, end)``, with ``dummy_variable`` taking
+    all integer values from ``start`` through ``end``. In accordance with
+    long-standing mathematical convention, the end term is included in the
+    summation.
+    Finite sums
+    ===========
+    For finite sums (and sums with symbolic limits assumed to be finite) we
+    follow the summation convention described by Karr [1], especially
+    definition 3 of section 1.4. The sum:
+    .. math::
+        \sum_{m \leq i < n} f(i)
+    has *the obvious meaning* for `m < n`, namely:
+    .. math::
+        \sum_{m \leq i < n} f(i) = f(m) + f(m+1) + \ldots + f(n-2) + f(n-1)
+    with the upper limit value `f(n)` excluded. The sum over an empty set is
+    zero if and only if `m = n`:
+    .. math::
+        \sum_{m \leq i < n} f(i) = 0  \quad \mathrm{for} \quad  m = n
+    Finally, for all other sums over empty sets we assume the following
+    definition:
+    .. math::
+        \sum_{m \leq i < n} f(i) = - \sum_{n \leq i < m} f(i)  \quad \mathrm{for} \quad  m > n
+    It is important to note that Karr defines all sums with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the summation convention. Indeed we have:
+    .. math::
+        \sum_{m \leq i < n} f(i) = \sum_{i = m}^{n - 1} f(i)
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+    Examples
+    ========
+    >>> from sympy.abc import i, k, m, n, x
+    >>> from sympy import Sum, factorial, oo, IndexedBase, Function
+    >>> Sum(k, (k, 1, m))
+    Sum(k, (k, 1, m))
+    >>> Sum(k, (k, 1, m)).doit()
+    m**2/2 + m/2
+    >>> Sum(k**2, (k, 1, m))
+    Sum(k**2, (k, 1, m))
+    >>> Sum(k**2, (k, 1, m)).doit()
+    m**3/3 + m**2/2 + m/6
+    >>> Sum(x**k, (k, 0, oo))
+    Sum(x**k, (k, 0, oo))
+    >>> Sum(x**k, (k, 0, oo)).doit()
+    Piecewise((1/(1 - x), Abs(x) < 1), (Sum(x**k, (k, 0, oo)), True))
+    >>> Sum(x**k/factorial(k), (k, 0, oo)).doit()
+    exp(x)
+    Here are examples to do summation with symbolic indices.  You
+    can use either Function of IndexedBase classes:
+    >>> f = Function('f')
+    >>> Sum(f(n), (n, 0, 3)).doit()
+    f(0) + f(1) + f(2) + f(3)
+    >>> Sum(f(n), (n, 0, oo)).doit()
+    Sum(f(n), (n, 0, oo))
+    >>> f = IndexedBase('f')
+    >>> Sum(f[n]**2, (n, 0, 3)).doit()
+    f[0]**2 + f[1]**2 + f[2]**2 + f[3]**2
+    An example showing that the symbolic result of a summation is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those sums by interchanging the limits according to the above rules:
+    >>> S = Sum(i, (i, 1, n)).doit()
+    >>> S
+    n**2/2 + n/2
+    >>> S.subs(n, -4)
+    6
+    >>> Sum(i, (i, 1, -4)).doit()
+    6
+    >>> Sum(-i, (i, -3, 0)).doit()
+    6
+    An explicit example of the Karr summation convention:
+    >>> S1 = Sum(i**2, (i, m, m+n-1)).doit()
+    >>> S1
+    m**2*n + m*n**2 - m*n + n**3/3 - n**2/2 + n/6
+    >>> S2 = Sum(i**2, (i, m+n, m-1)).doit()
+    >>> S2
+    -m**2*n - m*n**2 + m*n - n**3/3 + n**2/2 - n/6
+    >>> S1 + S2
+    0
+    >>> S3 = Sum(i, (i, m, m-1)).doit()
+    >>> S3
+    0
+    See Also
+    ========
+    summation
+    Product, sympy.concrete.products.product
+    References
+    ==========
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Summation#Capital-sigma_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_sum
+    """
+    __slots__ = ()
+    limits: tTuple[tTuple[Symbol, Expr, Expr]]
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
+        if not hasattr(obj, 'limits'):
+            return obj
+        if any(len(l) != 3 or None in l for l in obj.limits):
+            raise ValueError('Sum requires values for lower and upper bounds.')
+        return obj
+    def _eval_is_zero(self):
+        # a Sum is only zero if its function is zero or if all terms
+        # cancel out. This only answers whether the summand is zero; if
+        # not then None is returned since we don't analyze whether all
+        # terms cancel out.
+        if self.function.is_zero or self.has_empty_sequence:
+            return True
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+        return self.function.is_extended_real
+    def _eval_is_positive(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_positive
+    def _eval_is_negative(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_negative
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            f = self.function.doit(**hints)
+        else:
+            f = self.function
+        # first make sure any definite limits have summation
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            elif did is not None:
+                did = did.xreplace(undo)
+            else:
+                did = self
+            return did
+        if self.function.is_Matrix:
+            expanded = self.expand()
+            if self != expanded:
+                return expanded.doit()
+            return _eval_matrix_sum(self)
+        for n, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif == -1:
+                # Any summation over an empty set is zero
+                return S.Zero
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = -f
+            newf = eval_sum(f, (i, a, b))
+            if newf is None:
+                if f == self.function:
+                    zeta_function = self.eval_zeta_function(f, (i, a, b))
+                    if zeta_function is not None:
+                        return zeta_function
+                    return self
+                else:
+                    return self.func(f, *self.limits[n:])
+            f = newf
+        if hints.get('deep', True):
+            # eval_sum could return partially unevaluated
+            # result with Piecewise.  In this case we won't
+            # doit() recursively.
+            if not isinstance(f, Piecewise):
+                return f.doit(**hints)
+        return f
+    def eval_zeta_function(self, f, limits):
+        """
+        Check whether the function matches with the zeta function.
+        If it matches, then return a `Piecewise` expression because
+        zeta function does not converge unless `s > 1` and `q > 0`
+        """
+        i, a, b = limits
+        w, y, z = Wild('w', exclude=[i]), Wild('y', exclude=[i]), Wild('z', exclude=[i])
+        result = f.match((w * i + y) ** (-z))
+        if result is not None and b is S.Infinity:
+            coeff = 1 / result[w] ** result[z]
+            s = result[z]
+            q = result[y] / result[w] + a
+            return Piecewise((coeff * zeta(s, q), And(q > 0, s > 1)), (self, True))
+    def _eval_derivative(self, x):
+        """
+        Differentiate wrt x as long as x is not in the free symbols of any of
+        the upper or lower limits.
+        Explanation
+        ===========
+        Sum(a*b*x, (x, 1, a)) can be differentiated wrt x or b but not `a`
+        since the value of the sum is discontinuous in `a`. In a case
+        involving a limit variable, the unevaluated derivative is returned.
+        """
+        # diff already confirmed that x is in the free symbols of self, but we
+        # don't want to differentiate wrt any free symbol in the upper or lower
+        # limits
+        # XXX remove this test for free_symbols when the default _eval_derivative is in
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+        # get limits and the function
+        f, limits = self.function, list(self.limits)
+        limit = limits.pop(-1)
+        if limits:  # f is the argument to a Sum
+            f = self.func(f, *limits)
+        _, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        df = Derivative(f, x, evaluate=True)
+        rv = self.func(df, limit)
+        return rv
+    def _eval_difference_delta(self, n, step):
+        k, _, upper = self.args[-1]
+        new_upper = upper.subs(n, n + step)
+        if len(self.args) == 2:
+            f = self.args[0]
+        else:
+            f = self.func(*self.args[:-1])
+        return Sum(f, (k, upper + 1, new_upper)).doit()
+    def _eval_simplify(self, **kwargs):
+        function = self.function
+        if kwargs.get('deep', True):
+            function = function.simplify(**kwargs)
+        # split the function into adds
+        terms = Add.make_args(expand(function))
+        s_t = [] # Sum Terms
+        o_t = [] # Other Terms
+        for term in terms:
+            if term.has(Sum):
+                # if there is an embedded sum here
+                # it is of the form x * (Sum(whatever))
+                # hence we make a Mul out of it, and simplify all interior sum terms
+                subterms = Mul.make_args(expand(term))
+                out_terms = []
+                for subterm in subterms:
+                    # go through each term
+                    if isinstance(subterm, Sum):
+                        # if it's a sum, simplify it
+                        out_terms.append(subterm._eval_simplify(**kwargs))
+                    else:
+                        # otherwise, add it as is
+                        out_terms.append(subterm)
+                # turn it back into a Mul
+                s_t.append(Mul(*out_terms))
+            else:
+                o_t.append(term)
+        # next try to combine any interior sums for further simplification
+        from sympy.simplify.simplify import factor_sum, sum_combine
+        result = Add(sum_combine(s_t), *o_t)
+        return factor_sum(result, limits=self.limits)
+    def is_convergent(self):
+        r"""
+        Checks for the convergence of a Sum.
+        Explanation
+        ===========
+        We divide the study of convergence of infinite sums and products in
+        two parts.
+        First Part:
+        One part is the question whether all the terms are well defined, i.e.,
+        they are finite in a sum and also non-zero in a product. Zero
+        is the analogy of (minus) infinity in products as
+        :math:`e^{-\infty} = 0`.
+        Second Part:
+        The second part is the question of convergence after infinities,
+        and zeros in products, have been omitted assuming that their number
+        is finite. This means that we only consider the tail of the sum or
+        product, starting from some point after which all terms are well
+        defined.
+        For example, in a sum of the form:
+        .. math::
+            \sum_{1 \leq i < \infty} \frac{1}{n^2 + an + b}
+        where a and b are numbers. The routine will return true, even if there
+        are infinities in the term sequence (at most two). An analogous
+        product would be:
+        .. math::
+            \prod_{1 \leq i < \infty} e^{\frac{1}{n^2 + an + b}}
+        This is how convergence is interpreted. It is concerned with what
+        happens at the limit. Finding the bad terms is another independent
+        matter.
+        Note: It is responsibility of user to see that the sum or product
+        is well defined.
+        There are various tests employed to check the convergence like
+        divergence test, root test, integral test, alternating series test,
+        comparison tests, Dirichlet tests. It returns true if Sum is convergent
+        and false if divergent and NotImplementedError if it cannot be checked.
+        References
+        ==========
+        .. [1] https://en.wikipedia.org/wiki/Convergence_tests
+        Examples
+        ========
+        >>> from sympy import factorial, S, Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
+        True
+        >>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
+        True
+        See Also
+        ========
+        Sum.is_absolutely_convergent
+        sympy.concrete.products.Product.is_convergent
+        """
+        p, q, r = symbols('p q r', cls=Wild)
+        sym = self.limits[0][0]
+        lower_limit = self.limits[0][1]
+        upper_limit = self.limits[0][2]
+        sequence_term = self.function.simplify()
+        if len(sequence_term.free_symbols) > 1:
+            raise NotImplementedError("convergence checking for more than one symbol "
+                                      "containing series is not handled")
+        if lower_limit.is_finite and upper_limit.is_finite:
+            return S.true
+        # transform sym -> -sym and swap the upper_limit = S.Infinity
+        # and lower_limit = - upper_limit
+        if lower_limit is S.NegativeInfinity:
+            if upper_limit is S.Infinity:
+                return Sum(sequence_term, (sym, 0, S.Infinity)).is_convergent() and \
+                        Sum(sequence_term, (sym, S.NegativeInfinity, 0)).is_convergent()
+            from sympy.simplify.simplify import simplify
+            sequence_term = simplify(sequence_term.xreplace({sym: -sym}))
+            lower_limit = -upper_limit
+            upper_limit = S.Infinity
+        sym_ = Dummy(sym.name, integer=True, positive=True)
+        sequence_term = sequence_term.xreplace({sym: sym_})
+        sym = sym_
+        interval = Interval(lower_limit, upper_limit)
+        # Piecewise function handle
+        if sequence_term.is_Piecewise:
+            for func, cond in sequence_term.args:
+                # see if it represents something going to oo
+                if cond == True or cond.as_set().sup is S.Infinity:
+                    s = Sum(func, (sym, lower_limit, upper_limit))
+                    return s.is_convergent()
+            return S.true
+        ###  -------- Divergence test ----------- ###
+        try:
+           lim_val = limit_seq(sequence_term, sym)
+           if lim_val is not None and lim_val.is_zero is False:
+               return S.false
+        except NotImplementedError:
+            pass
+        try:
+            lim_val_abs = limit_seq(abs(sequence_term), sym)
+            if lim_val_abs is not None and lim_val_abs.is_zero is False:
+                return S.false
+        except NotImplementedError:
+            pass
+        order = O(sequence_term, (sym, S.Infinity))
+        ### --------- p-series test (1/n**p) ---------- ###
+        p_series_test = order.expr.match(sym**p)
+        if p_series_test is not None:
+            if p_series_test[p] < -1:
+                return S.true
+            if p_series_test[p] >= -1:
+                return S.false
+        ### ------------- comparison test ------------- ###
+        # 1/(n**p*log(n)**q*log(log(n))**r) comparison
+        n_log_test = (order.expr.match(1/(sym**p*log(1/sym)**q*log(-log(1/sym))**r)) or
+                      order.expr.match(1/(sym**p*(-log(1/sym))**q*log(-log(1/sym))**r)))
+        if n_log_test is not None:
+            if (n_log_test[p] > 1 or
+                (n_log_test[p] == 1 and n_log_test[q] > 1) or
+                (n_log_test[p] == n_log_test[q] == 1 and n_log_test[r] > 1)):
+                    return S.true
+            return S.false
+        ### ------------- Limit comparison test -----------###
+        # (1/n) comparison
+        try:
+            lim_comp = limit_seq(sym*sequence_term, sym)
+            if lim_comp is not None and lim_comp.is_number and lim_comp > 0:
+                return S.false
+        except NotImplementedError:
+            pass
+        ### ----------- ratio test ---------------- ###
+        next_sequence_term = sequence_term.xreplace({sym: sym + 1})
+        from sympy.simplify.combsimp import combsimp
+        from sympy.simplify.powsimp import powsimp
+        ratio = combsimp(powsimp(next_sequence_term/sequence_term))
+        try:
+            lim_ratio = limit_seq(ratio, sym)
+            if lim_ratio is not None and lim_ratio.is_number:
+                if abs(lim_ratio) > 1:
+                    return S.false
+                if abs(lim_ratio) < 1:
+                    return S.true
+        except NotImplementedError:
+            lim_ratio = None
+        ### ---------- Raabe's test -------------- ###
+        if lim_ratio == 1:  # ratio test inconclusive
+            test_val = sym*(sequence_term/
+                         sequence_term.subs(sym, sym + 1) - 1)
+            test_val = test_val.gammasimp()
+            try:
+                lim_val = limit_seq(test_val, sym)
+                if lim_val is not None and lim_val.is_number:
+                    if lim_val > 1:
+                        return S.true
+                    if lim_val < 1:
+                        return S.false
+            except NotImplementedError:
+                pass
+        ### ----------- root test ---------------- ###
+        # lim = Limit(abs(sequence_term)**(1/sym), sym, S.Infinity)
+        try:
+            lim_evaluated = limit_seq(abs(sequence_term)**(1/sym), sym)
+            if lim_evaluated is not None and lim_evaluated.is_number:
+                if lim_evaluated < 1:
+                    return S.true
+                if lim_evaluated > 1:
+                    return S.false
+        except NotImplementedError:
+            pass
+        ### ------------- alternating series test ----------- ###
+        dict_val = sequence_term.match(S.NegativeOne**(sym + p)*q)
+        if not dict_val[p].has(sym) and is_decreasing(dict_val[q], interval):
+            return S.true
+        ### ------------- integral test -------------- ###
+        check_interval = None
+        from sympy.solvers.solveset import solveset
+        maxima = solveset(sequence_term.diff(sym), sym, interval)
+        if not maxima:
+            check_interval = interval
+        elif isinstance(maxima, FiniteSet) and maxima.sup.is_number:
+            check_interval = Interval(maxima.sup, interval.sup)
+        if (check_interval is not None and
+            (is_decreasing(sequence_term, check_interval) or
+            is_decreasing(-sequence_term, check_interval))):
+                integral_val = Integral(
+                    sequence_term, (sym, lower_limit, upper_limit))
+                try:
+                    integral_val_evaluated = integral_val.doit()
+                    if integral_val_evaluated.is_number:
+                        return S(integral_val_evaluated.is_finite)
+                except NotImplementedError:
+                    pass
+        ### ----- Dirichlet and bounded times convergent tests ----- ###
+        # TODO
+        #
+        # Dirichlet_test
+        # https://en.wikipedia.org/wiki/Dirichlet%27s_test
+        #
+        # Bounded times convergent test
+        # It is based on comparison theorems for series.
+        # In particular, if the general term of a series can
+        # be written as a product of two terms a_n and b_n
+        # and if a_n is bounded and if Sum(b_n) is absolutely
+        # convergent, then the original series Sum(a_n * b_n)
+        # is absolutely convergent and so convergent.
+        #
+        # The following code can grows like 2**n where n is the
+        # number of args in order.expr
+        # Possibly combined with the potentially slow checks
+        # inside the loop, could make this test extremely slow
+        # for larger summation expressions.
+        if order.expr.is_Mul:
+            args = order.expr.args
+            argset = set(args)
+            ### -------------- Dirichlet tests -------------- ###
+            m = Dummy('m', integer=True)
+            def _dirichlet_test(g_n):
+                try:
+                    ing_val = limit_seq(Sum(g_n, (sym, interval.inf, m)).doit(), m)
+                    if ing_val is not None and ing_val.is_finite:
+                        return S.true
+                except NotImplementedError:
+                    pass
+            ### -------- bounded times convergent test ---------###
+            def _bounded_convergent_test(g1_n, g2_n):
+                try:
+                    lim_val = limit_seq(g1_n, sym)
+                    if lim_val is not None and (lim_val.is_finite or (
+                        isinstance(lim_val, AccumulationBounds)
+                        and (lim_val.max - lim_val.min).is_finite)):
+                            if Sum(g2_n, (sym, lower_limit, upper_limit)).is_absolutely_convergent():
+                                return S.true
+                except NotImplementedError:
+                    pass
+            for n in range(1, len(argset)):
+                for a_tuple in itertools.combinations(args, n):
+                    b_set = argset - set(a_tuple)
+                    a_n = Mul(*a_tuple)
+                    b_n = Mul(*b_set)
+                    if is_decreasing(a_n, interval):
+                        dirich = _dirichlet_test(b_n)
+                        if dirich is not None:
+                            return dirich
+                    bc_test = _bounded_convergent_test(a_n, b_n)
+                    if bc_test is not None:
+                        return bc_test
+        _sym = self.limits[0][0]
+        sequence_term = sequence_term.xreplace({sym: _sym})
+        raise NotImplementedError("The algorithm to find the Sum convergence of %s "
+                                  "is not yet implemented" % (sequence_term))
+    def is_absolutely_convergent(self):
+        """
+        Checks for the absolute convergence of an infinite series.
+        Same as checking convergence of absolute value of sequence_term of
+        an infinite series.
+        References
+        ==========
+        .. [1] https://en.wikipedia.org/wiki/Absolute_convergence
+        Examples
+        ========
+        >>> from sympy import Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent()
+        False
+        >>> Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent()
+        True
+        See Also
+        ========
+        Sum.is_convergent
+        """
+        return Sum(abs(self.function), self.limits).is_convergent()
+    def euler_maclaurin(self, m=0, n=0, eps=0, eval_integral=True):
+        """
+        Return an Euler-Maclaurin approximation of self, where m is the
+        number of leading terms to sum directly and n is the number of
+        terms in the tail.
+        With m = n = 0, this is simply the corresponding integral
+        plus a first-order endpoint correction.
+        Returns (s, e) where s is the Euler-Maclaurin approximation
+        and e is the estimated error (taken to be the magnitude of
+        the first omitted term in the tail):
+            >>> from sympy.abc import k, a, b
+            >>> from sympy import Sum
+            >>> Sum(1/k, (k, 2, 5)).doit().evalf()
+            1.28333333333333
+            >>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin()
+            >>> s
+            -log(2) + 7/20 + log(5)
+            >>> from sympy import sstr
+            >>> print(sstr((s.evalf(), e.evalf()), full_prec=True))
+            (1.26629073187415, 0.0175000000000000)
+        The endpoints may be symbolic:
+            >>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin()
+            >>> s
+            -log(a) + log(b) + 1/(2*b) + 1/(2*a)
+            >>> e
+            Abs(1/(12*b**2) - 1/(12*a**2))
+        If the function is a polynomial of degree at most 2n+1, the
+        Euler-Maclaurin formula becomes exact (and e = 0 is returned):
+            >>> Sum(k, (k, 2, b)).euler_maclaurin()
+            (b**2/2 + b/2 - 1, 0)
+            >>> Sum(k, (k, 2, b)).doit()
+            b**2/2 + b/2 - 1
+        With a nonzero eps specified, the summation is ended
+        as soon as the remainder term is less than the epsilon.
+        """
+        m = int(m)
+        n = int(n)
+        f = self.function
+        if len(self.limits) != 1:
+            raise ValueError("More than 1 limit")
+        i, a, b = self.limits[0]
+        if (a > b) == True:
+            if a - b == 1:
+                return S.Zero, S.Zero
+            a, b = b + 1, a - 1
+            f = -f
+        s = S.Zero
+        if m:
+            if b.is_Integer and a.is_Integer:
+                m = min(m, b - a + 1)
+            if not eps or f.is_polynomial(i):
+                s = Add(*[f.subs(i, a + k) for k in range(m)])
+            else:
+                term = f.subs(i, a)
+                if term:
+                    test = abs(term.evalf(3)) < eps
+                    if test == True:
+                        return s, abs(term)
+                    elif not (test == False):
+                        # a symbolic Relational class, can't go further
+                        return term, S.Zero
+                s = term
+                for k in range(1, m):
+                    term = f.subs(i, a + k)
+                    if abs(term.evalf(3)) < eps and term != 0:
+                        return s, abs(term)
+                    s += term
+            if b - a + 1 == m:
+                return s, S.Zero
+            a += m
+        x = Dummy('x')
+        I = Integral(f.subs(i, x), (x, a, b))
+        if eval_integral:
+            I = I.doit()
+        s += I
+        def fpoint(expr):
+            if b is S.Infinity:
+                return expr.subs(i, a), 0
+            return expr.subs(i, a), expr.subs(i, b)
+        fa, fb = fpoint(f)
+        iterm = (fa + fb)/2
+        g = f.diff(i)
+        for k in range(1, n + 2):
+            ga, gb = fpoint(g)
+            term = bernoulli(2*k)/factorial(2*k)*(gb - ga)
+            if k > n:
+                break
+            if eps and term:
+                term_evalf = term.evalf(3)
+                if term_evalf is S.NaN:
+                    return S.NaN, S.NaN
+                if abs(term_evalf) < eps:
+                    break
+            s += term
+            g = g.diff(i, 2, simplify=False)
+        return s + iterm, abs(term)
+    def reverse_order(self, *indices):
+        """
+        Reverse the order of a limit in a Sum.
+        Explanation
+        ===========
+        ``reverse_order(self, *indices)`` reverses some limits in the expression
+        ``self`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+        Examples
+        ========
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> Sum(x, (x, 0, 3)).reverse_order(x)
+        Sum(-x, (x, 4, -1))
+        >>> Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(x, y)
+        Sum(x*y, (x, 6, 0), (y, 7, -1))
+        >>> Sum(x, (x, a, b)).reverse_order(x)
+        Sum(-x, (x, b + 1, a - 1))
+        >>> Sum(x, (x, a, b)).reverse_order(0)
+        Sum(-x, (x, b + 1, a - 1))
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+        >>> S = Sum(x**2, (x, a, b), (x, c, d))
+        >>> S
+        Sum(x**2, (x, a, b), (x, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x**2, (x, b + 1, a - 1), (x, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x**2, (x, b + 1, a - 1), (x, d + 1, c - 1))
+        Of course we can mix both notations:
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        See Also
+        ========
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+        References
+        ==========
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+        """
+        l_indices = list(indices)
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = self.index(indx)
+        e = 1
+        limits = []
+        for i, limit in enumerate(self.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+        return Sum(e * self.function, *limits)
+    def _eval_rewrite_as_Product(self, *args, **kwargs):
+        from sympy.concrete.products import Product
+        if self.function.is_extended_real:
+            return log(Product(exp(self.function), *self.limits))
+def summation(f, *symbols, **kwargs):
+    r"""
+    Compute the summation of f with respect to symbols.
+    Explanation
+    ===========
+    The notation for symbols is similar to the notation used in Integral.
+    summation(f, (i, a, b)) computes the sum of f with respect to i from a to b,
+    i.e.,
+    ::
+                                    b
+                                  ____
+                                  \   `
+        summation(f, (i, a, b)) =  )    f
+                                  /___,
+                                  i = a
+    If it cannot compute the sum, it returns an unevaluated Sum object.
+    Repeated sums can be computed by introducing additional symbols tuples::
+    Examples
+    ========
+    >>> from sympy import summation, oo, symbols, log
+    >>> i, n, m = symbols('i n m', integer=True)
+    >>> summation(2*i - 1, (i, 1, n))
+    n**2
+    >>> summation(1/2**i, (i, 0, oo))
+    2
+    >>> summation(1/log(n)**n, (n, 2, oo))
+    Sum(log(n)**(-n), (n, 2, oo))
+    >>> summation(i, (i, 0, n), (n, 0, m))
+    m**3/6 + m**2/2 + m/3
+    >>> from sympy.abc import x
+    >>> from sympy import factorial
+    >>> summation(x**n/factorial(n), (n, 0, oo))
+    exp(x)
+    See Also
+    ========
+    Sum
+    Product, sympy.concrete.products.product
+    """
+    return Sum(f, *symbols, **kwargs).doit(deep=False)
+def telescopic_direct(L, R, n, limits):
+    """
+    Returns the direct summation of the terms of a telescopic sum
+    Explanation
+    ===========
+    L is the term with lower index
+    R is the term with higher index
+    n difference between the indexes of L and R
+    Examples
+    ========
+    >>> from sympy.concrete.summations import telescopic_direct
+    >>> from sympy.abc import k, a, b
+    >>> telescopic_direct(1/k, -1/(k+2), 2, (k, a, b))
+    -1/(b + 2) - 1/(b + 1) + 1/(a + 1) + 1/a
+    """
+    (i, a, b) = limits
+    return Add(*[L.subs(i, a + m) + R.subs(i, b - m) for m in range(n)])
+def telescopic(L, R, limits):
+    '''
+    Tries to perform the summation using the telescopic property.
+    Return None if not possible.
+    '''
+    (i, a, b) = limits
+    if L.is_Add or R.is_Add:
+        return None
+    # We want to solve(L.subs(i, i + m) + R, m)
+    # First we try a simple match since this does things that
+    # solve doesn't do, e.g. solve(cos(k+m)-cos(k), m) gives
+    # a more complicated solution than m == 0.
+    k = Wild("k")
+    sol = (-R).match(L.subs(i, i + k))
+    s = None
+    if sol and k in sol:
+        s = sol[k]
+        if not (s.is_Integer and L.subs(i, i + s) + R == 0):
+            # invalid match or match didn't work
+            s = None
+    # But there are things that match doesn't do that solve
+    # can do, e.g. determine that 1/(x + m) = 1/(1 - x) when m = 1
+    if s is None:
+        m = Dummy('m')
+        try:
+            from sympy.solvers.solvers import solve
+            sol = solve(L.subs(i, i + m) + R, m) or []
+        except NotImplementedError:
+            return None
+        sol = [si for si in sol if si.is_Integer and
+               (L.subs(i, i + si) + R).expand().is_zero]
+        if len(sol) != 1:
+            return None
+        s = sol[0]
+    if s < 0:
+        return telescopic_direct(R, L, abs(s), (i, a, b))
+    elif s > 0:
+        return telescopic_direct(L, R, s, (i, a, b))
+def eval_sum(f, limits):
+    (i, a, b) = limits
+    if f.is_zero:
+        return S.Zero
+    if i not in f.free_symbols:
+        return f*(b - a + 1)
+    if a == b:
+        return f.subs(i, a)
+    if isinstance(f, Piecewise):
+        if not any(i in arg.args[1].free_symbols for arg in f.args):
+            # Piecewise conditions do not depend on the dummy summation variable,
+            # therefore we can fold:     Sum(Piecewise((e, c), ...), limits)
+            #                        --> Piecewise((Sum(e, limits), c), ...)
+            newargs = []
+            for arg in f.args:
+                newexpr = eval_sum(arg.expr, limits)
+                if newexpr is None:
+                    return None
+                newargs.append((newexpr, arg.cond))
+            return f.func(*newargs)
+    if f.has(KroneckerDelta):
+        from .delta import deltasummation, _has_simple_delta
+        f = f.replace(
+            lambda x: isinstance(x, Sum),
+            lambda x: x.factor()
+        )
+        if _has_simple_delta(f, limits[0]):
+            return deltasummation(f, limits)
+    dif = b - a
+    definite = dif.is_Integer
+    # Doing it directly may be faster if there are very few terms.
+    if definite and (dif < 100):
+        return eval_sum_direct(f, (i, a, b))
+    if isinstance(f, Piecewise):
+        return None
+    # Try to do it symbolically. Even when the number of terms is
+    # known, this can save time when b-a is big.
+    value = eval_sum_symbolic(f.expand(), (i, a, b))
+    if value is not None:
+        return value
+    # Do it directly
+    if definite:
+        return eval_sum_direct(f, (i, a, b))
+def eval_sum_direct(expr, limits):
+    """
+    Evaluate expression directly, but perform some simple checks first
+    to possibly result in a smaller expression and faster execution.
+    """
+    (i, a, b) = limits
+    dif = b - a
+    # Linearity
+    if expr.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+            if not L.has(i):
+                sR = eval_sum_direct(R, (i, a, b))
+                if sR:
+                    return L*sR
+            if not R.has(i):
+                sL = eval_sum_direct(L, (i, a, b))
+                if sL:
+                    return sL*R
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        expr = apart(expr, i)  # see if it becomes an Add
+    except PolynomialError:
+        pass
+    if expr.is_Add:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*(dif + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+            lsum = eval_sum_direct(L, (i, a, b))
+            rsum = eval_sum_direct(R, (i, a, b))
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+    return Add(*[expr.subs(i, a + j) for j in range(dif + 1)])
+def eval_sum_symbolic(f, limits):
+    f_orig = f
+    (i, a, b) = limits
+    if not f.has(i):
+        return f*(b - a + 1)
+    # Linearity
+    if f.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = f.as_two_terms()
+            if not L.has(i):
+                sR = eval_sum_symbolic(R, (i, a, b))
+                if sR:
+                    return L*sR
+            if not R.has(i):
+                sL = eval_sum_symbolic(L, (i, a, b))
+                if sL:
+                    return sL*R
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        f = apart(f, i)
+    except PolynomialError:
+        pass
+    if f.is_Add:
+        L, R = f.as_two_terms()
+        lrsum = telescopic(L, R, (i, a, b))
+        if lrsum:
+            return lrsum
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*(b - a + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            lsum = eval_sum_symbolic(L, (i, a, b))
+            rsum = eval_sum_symbolic(R, (i, a, b))
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+    # Polynomial terms with Faulhaber's formula
+    n = Wild('n')
+    result = f.match(i**n)
+    if result is not None:
+        n = result[n]
+        if n.is_Integer:
+            if n >= 0:
+                if (b is S.Infinity and a is not S.NegativeInfinity) or \
+                   (a is S.NegativeInfinity and b is not S.Infinity):
+                    return S.Infinity
+                return ((bernoulli(n + 1, b + 1) - bernoulli(n + 1, a))/(n + 1)).expand()
+            elif a.is_Integer and a >= 1:
+                if n == -1:
+                    return harmonic(b) - harmonic(a - 1)
+                else:
+                    return harmonic(b, abs(n)) - harmonic(a - 1, abs(n))
+    if not (a.has(S.Infinity, S.NegativeInfinity) or
+            b.has(S.Infinity, S.NegativeInfinity)):
+        # Geometric terms
+        c1 = Wild('c1', exclude=[i])
+        c2 = Wild('c2', exclude=[i])
+        c3 = Wild('c3', exclude=[i])
+        wexp = Wild('wexp')
+        # Here we first attempt powsimp on f for easier matching with the
+        # exponential pattern, and attempt expansion on the exponent for easier
+        # matching with the linear pattern.
+        e = f.powsimp().match(c1 ** wexp)
+        if e is not None:
+            e_exp = e.pop(wexp).expand().match(c2*i + c3)
+            if e_exp is not None:
+                e.update(e_exp)
+                p = (c1**c3).subs(e)
+                q = (c1**c2).subs(e)
+                r = p*(q**a - q**(b + 1))/(1 - q)
+                l = p*(b - a + 1)
+                return Piecewise((l, Eq(q, S.One)), (r, True))
+        r = gosper_sum(f, (i, a, b))
+        if isinstance(r, (Mul,Add)):
+            from sympy.simplify.radsimp import denom
+            from sympy.solvers.solvers import solve
+            non_limit = r.free_symbols - Tuple(*limits[1:]).free_symbols
+            den = denom(together(r))
+            den_sym = non_limit & den.free_symbols
+            args = []
+            for v in ordered(den_sym):
+                try:
+                    s = solve(den, v)
+                    m = Eq(v, s[0]) if s else S.false
+                    if m != False:
+                        args.append((Sum(f_orig.subs(*m.args), limits).doit(), m))
+                    break
+                except NotImplementedError:
+                    continue
+            args.append((r, True))
+            return Piecewise(*args)
+        if r not in (None, S.NaN):
+            return r
+    h = eval_sum_hyper(f_orig, (i, a, b))
+    if h is not None:
+        return h
+    r = eval_sum_residue(f_orig, (i, a, b))
+    if r is not None:
+        return r
+    factored = f_orig.factor()
+    if factored != f_orig:
+        return eval_sum_symbolic(factored, (i, a, b))
+def _eval_sum_hyper(f, i, a):
+    """ Returns (res, cond). Sums from a to oo. """
+    if a != 0:
+        return _eval_sum_hyper(f.subs(i, i + a), i, 0)
+    if f.subs(i, 0) == 0:
+        from sympy.simplify.simplify import simplify
+        if simplify(f.subs(i, Dummy('i', integer=True, positive=True))) == 0:
+            return S.Zero, True
+        return _eval_sum_hyper(f.subs(i, i + 1), i, 0)
+    from sympy.simplify.simplify import hypersimp
+    hs = hypersimp(f, i)
+    if hs is None:
+        return None
+    if isinstance(hs, Float):
+        from sympy.simplify.simplify import nsimplify
+        hs = nsimplify(hs)
+    from sympy.simplify.combsimp import combsimp
+    from sympy.simplify.hyperexpand import hyperexpand
+    from sympy.simplify.radsimp import fraction
+    numer, denom = fraction(factor(hs))
+    top, topl = numer.as_coeff_mul(i)
+    bot, botl = denom.as_coeff_mul(i)
+    ab = [top, bot]
+    factors = [topl, botl]
+    params = [[], []]
+    for k in range(2):
+        for fac in factors[k]:
+            mul = 1
+            if fac.is_Pow:
+                mul = fac.exp
+                fac = fac.base
+                if not mul.is_Integer:
+                    return None
+            p = Poly(fac, i)
+            if p.degree() != 1:
+                return None
+            m, n = p.all_coeffs()
+            ab[k] *= m**mul
+            params[k] += [n/m]*mul
+    # Add "1" to numerator parameters, to account for implicit n! in
+    # hypergeometric series.
+    ap = params[0] + [1]
+    bq = params[1]
+    x = ab[0]/ab[1]
+    h = hyper(ap, bq, x)
+    f = combsimp(f)
+    return f.subs(i, 0)*hyperexpand(h), h.convergence_statement
+def eval_sum_hyper(f, i_a_b):
+    i, a, b = i_a_b
+    if f.is_hypergeometric(i) is False:
+        return
+    if (b - a).is_Integer:
+        # We are never going to do better than doing the sum in the obvious way
+        return None
+    old_sum = Sum(f, (i, a, b))
+    if b != S.Infinity:
+        if a is S.NegativeInfinity:
+            res = _eval_sum_hyper(f.subs(i, -i), i, -b)
+            if res is not None:
+                return Piecewise(res, (old_sum, True))
+        else:
+            n_illegal = lambda x: sum(x.count(_) for _ in _illegal)
+            had = n_illegal(f)
+            # check that no extra illegals are introduced
+            res1 = _eval_sum_hyper(f, i, a)
+            if res1 is None or n_illegal(res1) > had:
+                return
+            res2 = _eval_sum_hyper(f, i, b + 1)
+            if res2 is None or n_illegal(res2) > had:
+                return
+            (res1, cond1), (res2, cond2) = res1, res2
+            cond = And(cond1, cond2)
+            if cond == False:
+                return None
+            return Piecewise((res1 - res2, cond), (old_sum, True))
+    if a is S.NegativeInfinity:
+        res1 = _eval_sum_hyper(f.subs(i, -i), i, 1)
+        res2 = _eval_sum_hyper(f, i, 0)
+        if res1 is None or res2 is None:
+            return None
+        res1, cond1 = res1
+        res2, cond2 = res2
+        cond = And(cond1, cond2)
+        if cond == False or cond.as_set() == S.EmptySet:
+            return None
+        return Piecewise((res1 + res2, cond), (old_sum, True))
+    # Now b == oo, a != -oo
+    res = _eval_sum_hyper(f, i, a)
+    if res is not None:
+        r, c = res
+        if c == False:
+            if r.is_number:
+                f = f.subs(i, Dummy('i', integer=True, positive=True) + a)
+                if f.is_positive or f.is_zero:
+                    return S.Infinity
+                elif f.is_negative:
+                    return S.NegativeInfinity
+            return None
+        return Piecewise(res, (old_sum, True))
+def eval_sum_residue(f, i_a_b):
+    r"""Compute the infinite summation with residues
+    Notes
+    =====
+    If $f(n), g(n)$ are polynomials with $\deg(g(n)) - \deg(f(n)) \ge 2$,
+    some infinite summations can be computed by the following residue
+    evaluations.
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\cot(\pi x) \frac{f(x)}{g(x)}, \alpha)
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} (-1)^n \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\csc(\pi x) \frac{f(x)}{g(x)}, \alpha)
+    Examples
+    ========
+    >>> from sympy import Sum, oo, Symbol
+    >>> x = Symbol('x')
+    Doubly infinite series of rational functions.
+    >>> Sum(1 / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/tanh(pi)
+    Doubly infinite alternating series of rational functions.
+    >>> Sum((-1)**x / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/sinh(pi)
+    Infinite series of even rational functions.
+    >>> Sum(1 / (x**2 + 1), (x, 0, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    Infinite series of alternating even rational functions.
+    >>> Sum((-1)**x / (x**2 + 1), (x, 0, oo)).doit()
+    pi/(2*sinh(pi)) + 1/2
+    This also have heuristics to transform arbitrarily shifted summand or
+    arbitrarily shifted summation range to the canonical problem the
+    formula can handle.
+    >>> Sum(1 / (x**2 + 2*x + 2), (x, -1, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 4*x + 5), (x, -2, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 1, oo)).doit()
+    -1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 2, oo)).doit()
+    -1 + pi/(2*tanh(pi))
+    References
+    ==========
+    .. [#] http://www.supermath.info/InfiniteSeriesandtheResidueTheorem.pdf
+    .. [#] Asmar N.H., Grafakos L. (2018) Residue Theory.
+           In: Complex Analysis with Applications.
+           Undergraduate Texts in Mathematics. Springer, Cham.
+           https://doi.org/10.1007/978-3-319-94063-2_5
+    """
+    i, a, b = i_a_b
+    def is_even_function(numer, denom):
+        """Test if the rational function is an even function"""
+        numer_even = all(i % 2 == 0 for (i,) in numer.monoms())
+        denom_even = all(i % 2 == 0 for (i,) in denom.monoms())
+        numer_odd = all(i % 2 == 1 for (i,) in numer.monoms())
+        denom_odd = all(i % 2 == 1 for (i,) in denom.monoms())
+        return (numer_even and denom_even) or (numer_odd and denom_odd)
+    def match_rational(f, i):
+        numer, denom = f.as_numer_denom()
+        try:
+            (numer, denom), opt = parallel_poly_from_expr((numer, denom), i)
+        except (PolificationFailed, PolynomialError):
+            return None
+        return numer, denom
+    def get_poles(denom):
+        roots = denom.sqf_part().all_roots()
+        roots = sift(roots, lambda x: x.is_integer)
+        if None in roots:
+            return None
+        int_roots, nonint_roots = roots[True], roots[False]
+        return int_roots, nonint_roots
+    def get_shift(denom):
+        n = denom.degree(i)
+        a = denom.coeff_monomial(i**n)
+        b = denom.coeff_monomial(i**(n-1))
+        shift = - b / a / n
+        return shift
+    #Need a dummy symbol with no assumptions set for get_residue_factor
+    z = Dummy('z')
+    def get_residue_factor(numer, denom, alternating):
+        residue_factor = (numer.as_expr() / denom.as_expr()).subs(i, z)
+        if not alternating:
+            residue_factor *= cot(S.Pi * z)
+        else:
+            residue_factor *= csc(S.Pi * z)
+        return residue_factor
+    # We don't know how to deal with symbolic constants in summand
+    if f.free_symbols - {i}:
+        return None
+    if not (a.is_Integer or a in (S.Infinity, S.NegativeInfinity)):
+        return None
+    if not (b.is_Integer or b in (S.Infinity, S.NegativeInfinity)):
+        return None
+    # Quick exit heuristic for the sums which doesn't have infinite range
+    if a != S.NegativeInfinity and b != S.Infinity:
+        return None
+    match = match_rational(f, i)
+    if match:
+        alternating = False
+        numer, denom = match
+    else:
+        match = match_rational(f / S.NegativeOne**i, i)
+        if match:
+            alternating = True
+            numer, denom = match
+        else:
+            return None
+    if denom.degree(i) - numer.degree(i) < 2:
+        return None
+    if (a, b) == (S.NegativeInfinity, S.Infinity):
+        poles = get_poles(denom)
+        if poles is None:
+            return None
+        int_roots, nonint_roots = poles
+        if int_roots:
+            return None
+        residue_factor = get_residue_factor(numer, denom, alternating)
+        residues = [residue(residue_factor, z, root) for root in nonint_roots]
+        return -S.Pi * sum(residues)
+    if not (a.is_finite and b is S.Infinity):
+        return None
+    if not is_even_function(numer, denom):
+        # Try shifting summation and check if the summand can be made
+        # and even function from the origin.
+        # Sum(f(n), (n, a, b)) => Sum(f(n + s), (n, a - s, b - s))
+        shift = get_shift(denom)
+        if not shift.is_Integer:
+            return None
+        if shift == 0:
+            return None
+        numer = numer.shift(shift)
+        denom = denom.shift(shift)
+        if not is_even_function(numer, denom):
+            return None
+        if alternating:
+            f = S.NegativeOne**i * (S.NegativeOne**shift * numer.as_expr() / denom.as_expr())
+        else:
+            f = numer.as_expr() / denom.as_expr()
+        return eval_sum_residue(f, (i, a-shift, b-shift))
+    poles = get_poles(denom)
+    if poles is None:
+        return None
+    int_roots, nonint_roots = poles
+    if int_roots:
+        int_roots = [int(root) for root in int_roots]
+        int_roots_max = max(int_roots)
+        int_roots_min = min(int_roots)
+        # Integer valued poles must be next to each other
+        # and also symmetric from origin (Because the function is even)
+        if not len(int_roots) == int_roots_max - int_roots_min + 1:
+            return None
+        # Check whether the summation indices contain poles
+        if a <= max(int_roots):
+            return None
+    residue_factor = get_residue_factor(numer, denom, alternating)
+    residues = [residue(residue_factor, z, root) for root in int_roots + nonint_roots]
+    full_sum = -S.Pi * sum(residues)
+    if not int_roots:
+        # Compute Sum(f, (i, 0, oo)) by adding a extraneous evaluation
+        # at the origin.
+        half_sum = (full_sum + f.xreplace({i: 0})) / 2
+        # Add and subtract extraneous evaluations
+        extraneous_neg = [f.xreplace({i: i0}) for i0 in range(int(a), 0)]
+        extraneous_pos = [f.xreplace({i: i0}) for i0 in range(0, int(a))]
+        result = half_sum + sum(extraneous_neg) - sum(extraneous_pos)
+        return result
+    # Compute Sum(f, (i, min(poles) + 1, oo))
+    half_sum = full_sum / 2
+    # Subtract extraneous evaluations
+    extraneous = [f.xreplace({i: i0}) for i0 in range(max(int_roots) + 1, int(a))]
+    result = half_sum - sum(extraneous)
+    return result
+def _eval_matrix_sum(expression):
+    f = expression.function
+    for limit in expression.limits:
+        i, a, b = limit
+        dif = b - a
+        if dif.is_Integer:
+            if (dif < 0) == True:
+                a, b = b + 1, a - 1
+                f = -f
+            newf = eval_sum_direct(f, (i, a, b))
+            if newf is not None:
+                return newf.doit()
+def _dummy_with_inherited_properties_concrete(limits):
+    """
+    Return a Dummy symbol that inherits as many assumptions as possible
+    from the provided symbol and limits.
+    If the symbol already has all True assumption shared by the limits
+    then return None.
+    """
+    x, a, b = limits
+    l = [a, b]
+    assumptions_to_consider = ['extended_nonnegative', 'nonnegative',
+                               'extended_nonpositive', 'nonpositive',
+                               'extended_positive', 'positive',
+                               'extended_negative', 'negative',
+                               'integer', 'rational', 'finite',
+                               'zero', 'real', 'extended_real']
+    assumptions_to_keep = {}
+    assumptions_to_add = {}
+    for assum in assumptions_to_consider:
+        assum_true = x._assumptions.get(assum, None)
+        if assum_true:
+            assumptions_to_keep[assum] = True
+        elif all(getattr(i, 'is_' + assum) for i in l):
+            assumptions_to_add[assum] = True
+    if assumptions_to_add:
+        assumptions_to_keep.update(assumptions_to_add)
+        return Dummy('d', **assumptions_to_keep)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/kind.py ADDED Viewed

	@@ -0,0 +1,97 @@

+# sympy.matrices.kind
+from sympy.core.kind import Kind, _NumberKind, NumberKind
+from sympy.core.mul import Mul
+class MatrixKind(Kind):
+    """
+    Kind for all matrices in SymPy.
+    Basic class for this kind is ``MatrixBase`` and ``MatrixExpr``,
+    but any expression representing the matrix can have this.
+    Parameters
+    ==========
+    element_kind : Kind
+        Kind of the element. Default is
+        :class:`sympy.core.kind.NumberKind`,
+        which means that the matrix contains only numbers.
+    Examples
+    ========
+    Any instance of matrix class has kind ``MatrixKind``:
+    >>> from sympy import MatrixSymbol
+    >>> A = MatrixSymbol('A', 2, 2)
+    >>> A.kind
+    MatrixKind(NumberKind)
+    An expression representing a matrix may not be an instance of
+    the Matrix class, but it will have kind ``MatrixKind``:
+    >>> from sympy import MatrixExpr, Integral
+    >>> from sympy.abc import x
+    >>> intM = Integral(A, x)
+    >>> isinstance(intM, MatrixExpr)
+    False
+    >>> intM.kind
+    MatrixKind(NumberKind)
+    Use ``isinstance()`` to check for ``MatrixKind`` without specifying the
+    element kind. Use ``is`` to check the kind including the element kind:
+    >>> from sympy import Matrix
+    >>> from sympy.core import NumberKind
+    >>> from sympy.matrices import MatrixKind
+    >>> M = Matrix([1, 2])
+    >>> isinstance(M.kind, MatrixKind)
+    True
+    >>> M.kind is MatrixKind(NumberKind)
+    True
+    See Also
+    ========
+    sympy.core.kind.NumberKind
+    sympy.core.kind.UndefinedKind
+    sympy.core.containers.TupleKind
+    sympy.sets.sets.SetKind
+    """
+    def __new__(cls, element_kind=NumberKind):
+        obj = super().__new__(cls, element_kind)
+        obj.element_kind = element_kind
+        return obj
+    def __repr__(self):
+        return "MatrixKind(%s)" % self.element_kind
+@Mul._kind_dispatcher.register(_NumberKind, MatrixKind)
+def num_mat_mul(k1, k2):
+    """
+    Return MatrixKind. The element kind is selected by recursive dispatching.
+    Do not need to dispatch in reversed order because KindDispatcher
+    searches for this automatically.
+    """
+    # Deal with Mul._kind_dispatcher's commutativity
+    # XXX: this function is called with either k1 or k2 as MatrixKind because
+    # the Mul kind dispatcher is commutative. Maybe it shouldn't be. Need to
+    # swap the args here because NumberKind does not have an element_kind
+    # attribute.
+    if not isinstance(k2, MatrixKind):
+        k1, k2 = k2, k1
+    elemk = Mul._kind_dispatcher(k1, k2.element_kind)
+    return MatrixKind(elemk)
+@Mul._kind_dispatcher.register(MatrixKind, MatrixKind)
+def mat_mat_mul(k1, k2):
+    """
+    Return MatrixKind. The element kind is selected by recursive dispatching.
+    """
+    elemk = Mul._kind_dispatcher(k1.element_kind, k2.element_kind)
+    return MatrixKind(elemk)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/ntheory/tests/__pycache__/test_factor_.cpython-311.pyc ADDED Viewed

Binary file (51.8 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/__pycache__/__init__.cpython-311.pyc ADDED Viewed

Binary file (224 Bytes). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/__pycache__/base_backend.cpython-311.pyc ADDED Viewed

Binary file (19.5 kB). View file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/plotting/backends/matplotlibbackend/__init__.py ADDED Viewed

	@@ -0,0 +1,5 @@

+from sympy.plotting.backends.matplotlibbackend.matplotlib import (
+    MatplotlibBackend, _matplotlib_list
+)
+__all__ = ["MatplotlibBackend", "_matplotlib_list"]