Add files using upload-large-folder tool

llm_tutorial/merged_models4/ja-en_en-ja_ties01/config.json

@@ -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_ties01/mergekit_config.yml

@@ -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.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/special_tokens_map.json

@@ -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_models4/ja-en_en-ja_ties01/tokenizer_config.json

@@ -0,0 +1,18 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "unk_token": "<unk>",
+  "bos_token": "<s>",
+  "eos_token": "</s>",
+  "pad_token": "<PAD|LLM-jp>",
+  "cls_token": "<CLS|LLM-jp>",
+  "sep_token": "<SEP|LLM-jp>",
+  "eod_token": "</s>",
+  "mask_token": "<MASK|LLM-jp>",
+  "extra_ids": 0,
+  "sp_model_kwargs": {},
+  "model_max_length": 1000000000000000019884624838656,
+  "clean_up_tokenization_spaces": false,
+  "special_tokens_map_file": null,
+  "tokenizer_class": "PreTrainedTokenizerFast"
+}

llm_tutorial/merged_models4/ja-en_en-ja_ties04-instruct/config.json

@@ -0,0 +1,30 @@
+{
+  "_name_or_path": "/work01/llm_tutorial/pretrained_lm/llm-jp/llm-jp-v3-3.7b-instruct",
+  "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_ties04-instruct/mergekit_config.yml

@@ -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.4
+  - 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.4
+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_ties04-instruct/model.safetensors.index.json

@@ -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_ties04-instruct/tokenizer_config.json

@@ -0,0 +1,84 @@
+{
+  "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>",
+  "chat_template": "{{bos_token}}{% for message in messages %}{% if message['role'] == 'user' %}{{ '\\n\\n### 指示:\\n' + message['content'] }}{% elif message['role'] == 'system' %}{{ '以下は、タスクを説明する指示です。要求を適切に満たす応答を書きなさい。' }}{% elif message['role'] == 'assistant' %}{{ '\\n\\n### 応答:\\n' + message['content'] + eos_token }}{% endif %}{% if loop.last and add_generation_prompt %}{{ '\\n\\n### 応答:\\n' }}{% endif %}{% endfor %}",
+  "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_ties04/config.json

@@ -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
+}

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

@@ -0,0 +1,919 @@
+from sympy.categories.diagram_drawing import _GrowableGrid, ArrowStringDescription
+from sympy.categories import (DiagramGrid, Object, NamedMorphism,
+                              Diagram, XypicDiagramDrawer, xypic_draw_diagram)
+from sympy.sets.sets import FiniteSet
+
+
+def test_GrowableGrid():
+    grid = _GrowableGrid(1, 2)
+
+    # Check dimensions.
+    assert grid.width == 1
+    assert grid.height == 2
+
+    # Check initialization of elements.
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+
+    # Check assignment to elements.
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+
+    # Check appending a row.
+    grid.append_row()
+
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    # Check appending a column.
+    grid.append_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] is None
+    assert grid[2, 1] is None
+
+    grid = _GrowableGrid(1, 2)
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    # Check prepending a row.
+    grid.prepend_row()
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] == 1
+    assert grid[2, 0] == "two"
+
+    # Check prepending a column.
+    grid.prepend_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] == 1
+    assert grid[2, 1] == "two"
+
+
+def test_DiagramGrid():
+    # Set up some objects and morphisms.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+
+    # A one-morphism diagram.
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid.morphisms == {f: FiniteSet()}
+
+    # A triangle.
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(),
+                              g * f: FiniteSet("unique")}
+
+    # A triangle with a "loop" morphism.
+    l_A = NamedMorphism(A, A, "l_A")
+    d = Diagram([f, g, l_A])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), l_A: FiniteSet()}
+
+    # A simple diagram.
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == D
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    assert str(grid) == '[[Object("A"), Object("B"), Object("D")], ' \
+        '[None, Object("C"), None]]'
+
+    # A chain of morphisms.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    k = NamedMorphism(D, E, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A square.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, D, "g")
+    h = NamedMorphism(A, C, "h")
+    k = NamedMorphism(C, D, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A strange diagram which resulted from a typo when creating a
+    # test for five lemma, but which allowed to stop one extra problem
+    # in the algorithm.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    # These 4 morphisms should be between primed objects.
+    j = NamedMorphism(A, B, "j")
+    k = NamedMorphism(B, C, "k")
+    l = NamedMorphism(C, D, "l")
+    m = NamedMorphism(D, E, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 4
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[2, 0] == C_
+    assert grid[2, 1] == D
+    assert grid[2, 2] == D_
+    assert grid[3, 0] is None
+    assert grid[3, 1] == E
+    assert grid[3, 2] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A cube.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A5
+    assert grid[0, 2] == A6
+    assert grid[0, 3] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == A1
+    assert grid[1, 2] == A2
+    assert grid[1, 3] is None
+    assert grid[2, 0] == A7
+    assert grid[2, 1] == A3
+    assert grid[2, 2] == A4
+    assert grid[2, 3] == A8
+
+    morphisms = {}
+    for m in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A line diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # Test the transposed version.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+
+    assert grid.width == 1
+    assert grid.height == 5
+    assert grid[0, 0] == A
+    assert grid[1, 0] == B
+    assert grid[2, 0] == C
+    assert grid[3, 0] == D
+    assert grid[4, 0] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # A pullback.
+    m1 = NamedMorphism(A, B, "m1")
+    m2 = NamedMorphism(A, C, "m2")
+    s1 = NamedMorphism(B, D, "s1")
+    s2 = NamedMorphism(C, D, "s2")
+    f1 = NamedMorphism(E, B, "f1")
+    f2 = NamedMorphism(E, C, "f2")
+    g = NamedMorphism(E, A, "g")
+
+    d = Diagram([m1, m2, s1, s2, f1, f2], {g: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == E
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid[1, 2] is None
+
+    morphisms = {g: FiniteSet("unique")}
+    for m in [m1, m2, s1, s2, f1, f2]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the pullback with sequential layout, just for stress
+    # testing.
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == D
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A
+    assert grid[0, 3] == C
+    assert grid[0, 4] == E
+    assert grid.morphisms == morphisms
+
+    # Test a pullback with object grouping.
+    grid = DiagramGrid(d, groups=FiniteSet(E, FiniteSet(A, B, C, D)))
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == E
+    assert grid[0, 1] == A
+    assert grid[0, 2] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid.morphisms == morphisms
+
+    # Five lemma, actually.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    j = NamedMorphism(A_, B_, "j")
+    k = NamedMorphism(B_, C_, "k")
+    l = NamedMorphism(C_, D_, "l")
+    m = NamedMorphism(D_, E_, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[0, 3] is None
+    assert grid[0, 4] is None
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[1, 3] == C_
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D
+    assert grid[2, 1] == E
+    assert grid[2, 2] is None
+    assert grid[2, 3] == D_
+    assert grid[2, 4] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping.
+    grid = DiagramGrid(d, FiniteSet(
+        FiniteSet(A, B, C, D, E), FiniteSet(A_, B_, C_, D_, E_)))
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping, but mixing containers
+    # to represent groups.
+    grid = DiagramGrid(d, [(A, B, C, D, E), {A_, B_, C_, D_, E_}])
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping and hints.
+    grid = DiagramGrid(d, {
+        FiniteSet(A, B, C, D, E): {"layout": "sequential",
+                                   "transpose": True},
+        FiniteSet(A_, B_, C_, D_, E_): {"layout": "sequential",
+                                        "transpose": True}},
+        transpose=True)
+
+    assert grid.width == 5
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid[1, 0] == A_
+    assert grid[1, 1] == B_
+    assert grid[1, 2] == C_
+    assert grid[1, 3] == D_
+    assert grid[1, 4] == E_
+    assert grid.morphisms == morphisms
+
+    # A two-triangle disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    f_ = NamedMorphism(A_, B_, "f")
+    g_ = NamedMorphism(B_, C_, "g")
+    d = Diagram([f, g, f_, g_], {g * f: "unique", g_ * f_: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A_
+    assert grid[0, 3] == B_
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid[1, 2] == C_
+    assert grid[1, 3] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), f_: FiniteSet(),
+                              g_: FiniteSet(), g * f: FiniteSet("unique"),
+                              g_ * f_: FiniteSet("unique")}
+
+    # A two-morphism disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(C, D, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet()}
+
+    # Test a one-object diagram.
+    f = NamedMorphism(A, A, "f")
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 1
+    assert grid.height == 1
+    assert grid[0, 0] == A
+
+    # Test a two-object disconnected diagram.
+    g = NamedMorphism(B, B, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+
+
+def test_DiagramGrid_pseudopod():
+    # Test a diagram in which even growing a pseudopod does not
+    # eventually help.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    F = Object("F")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f1 = NamedMorphism(A, B, "f1")
+    f2 = NamedMorphism(A, C, "f2")
+    f3 = NamedMorphism(A, D, "f3")
+    f4 = NamedMorphism(A, E, "f4")
+    f5 = NamedMorphism(A, A_, "f5")
+    f6 = NamedMorphism(A, B_, "f6")
+    f7 = NamedMorphism(A, C_, "f7")
+    f8 = NamedMorphism(A, D_, "f8")
+    f9 = NamedMorphism(A, E_, "f9")
+    f10 = NamedMorphism(A, F, "f10")
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] == E
+    assert grid[0, 1] == C
+    assert grid[0, 2] == C_
+    assert grid[0, 3] == E_
+    assert grid[0, 4] == F
+    assert grid[1, 0] == D
+    assert grid[1, 1] == A
+    assert grid[1, 2] == A_
+    assert grid[1, 3] is None
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D_
+    assert grid[2, 1] == B
+    assert grid[2, 2] == B_
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+
+    morphisms = {}
+    for f in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]:
+        morphisms[f] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+
+def test_ArrowStringDescription():
+    astr = ArrowStringDescription("cm", "", None, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "^", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@/^12cm/[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@(r,u)@{-->}[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "_", 12, "", "", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@/_12cm/@{-->}[dr]_{f}"
+
+
+def test_XypicDiagramDrawer_line():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{f} & B \\ar[r]^{g} & C \\ar[r]^{h} & D \\ar[r]^{i} & E \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\\\\n" \
+        "B \\ar[d]^{g} \\\\\n" \
+        "C \\ar[d]^{h} \\\\\n" \
+        "D \\ar[d]^{i} \\\\\n" \
+        "E \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_triangle():
+    # A triangle diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]_{g\\circ f} \\ar[r]^{f} & B \\ar[ld]^{g} \\\\\n" \
+        "C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram, with a masked morphism.
+    assert drawer.draw(d, grid, masked=[g]) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B & \n" \
+        "}\n"
+
+    # The same diagram with a formatter for "unique".
+    def formatter(astr):
+        astr.label = "\\exists !" + astr.label
+        astr.arrow_style = "{-->}"
+
+    drawer.arrow_formatters["unique"] = formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^{\\exists !g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram with a default formatter.
+    def default_formatter(astr):
+        astr.label_displacement = "(0.45)"
+
+    drawer.default_arrow_formatter = default_formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^(0.45){\\exists !g\\circ f} \\ar[d]_(0.45){f} & C \\\\\n" \
+        "B \\ar[ru]_(0.45){g} & \n" \
+        "}\n"
+
+    # A triangle diagram with a lot of morphisms between the same
+    # objects.
+    f1 = NamedMorphism(B, A, "f1")
+    f2 = NamedMorphism(A, B, "f2")
+    g1 = NamedMorphism(C, B, "g1")
+    g2 = NamedMorphism(B, C, "g2")
+    d = Diagram([f, f1, f2, g, g1, g2], {f1 * g1: "unique", g2 * f2: "unique"})
+
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid, masked=[f1*g1*g2*f2, g2*f2*f1*g1]) == \
+        "\\xymatrix{\n" \
+        "A \\ar[r]^{g_{2}\\circ f_{2}} \\ar[d]_{f} \\ar@/^3mm/[d]^{f_{2}} " \
+        "& C \\ar@/^3mm/[l]^{f_{1}\\circ g_{1}} \\ar@/^3mm/[ld]^{g_{1}} \\\\\n" \
+        "B \\ar@/^3mm/[u]^{f_{1}} \\ar[ru]_{g} \\ar@/^3mm/[ru]^{g_{2}} & \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_cube():
+    # A cube diagram.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& A_{5} \\ar[r]^{f_{5}} \\ar[ldd]_{f_{6}} & A_{6} \\ar[rdd]^{f_{7}} " \
+        "& \\\\\n" \
+        "& A_{1} \\ar[r]^{f_{1}} \\ar[d]^{f_{2}} \\ar[u]^{f_{9}} & A_{2} " \
+        "\\ar[d]^{f_{3}} \\ar[u]_{f_{10}} & \\\\\n" \
+        "A_{7} \\ar@/_3mm/[rrr]_{f_{8}} & A_{3} \\ar[r]^{f_{3}} \\ar[l]_{f_{11}} " \
+        "& A_{4} \\ar[r]^{f_{11}} & A_{8} \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& & A_{7} \\ar@/^3mm/[ddd]^{f_{8}} \\\\\n" \
+        "A_{5} \\ar[d]_{f_{5}} \\ar[rru]^{f_{6}} & A_{1} \\ar[d]^{f_{1}} " \
+        "\\ar[r]^{f_{2}} \\ar[l]^{f_{9}} & A_{3} \\ar[d]_{f_{3}} " \
+        "\\ar[u]^{f_{11}} \\\\\n" \
+        "A_{6} \\ar[rrd]_{f_{7}} & A_{2} \\ar[r]^{f_{3}} \\ar[l]^{f_{10}} " \
+        "& A_{4} \\ar[d]_{f_{11}} \\\\\n" \
+        "& & A_{8} \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_curved_and_loops():
+    # A simple diagram, with a curved arrow.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} & B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_3mm/[ll]_{h} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # The same diagram, larger and rotated.
+    assert drawer.draw(d, grid, diagram_format="@+1cm@dr") == \
+        "\\xymatrix@+1cm@dr{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # A simple diagram with three curved arrows.
+    h1 = NamedMorphism(D, A, "h1")
+    h2 = NamedMorphism(A, D, "h2")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k, h1, h2])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} & \n" \
+        "}\n"
+
+    # The same diagram, with "loop" morphisms.
+    l_A = NamedMorphism(A, A, "l_A")
+    l_D = NamedMorphism(D, D, "l_D")
+    l_C = NamedMorphism(C, C, "l_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "& B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_7mm/[ll]_{h} " \
+        "\\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with "loop" morphisms, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object.
+    l_A_ = NamedMorphism(A, A, "n_A")
+    l_D_ = NamedMorphism(D, D, "n_D")
+    l_C_ = NamedMorphism(C, C, "n_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C, l_A_, l_D_, l_C_])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(l,d)[]^{n_{A}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} " \
+        "\\ar@/^3mm/@(d,r)[]^{n_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(u,l)[]^{n_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} \\ar@/^3mm/@(d,r)[]^{n_{D}} & \n" \
+        "}\n"
+
+
+def test_xypic_draw_diagram():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == xypic_draw_diagram(d, layout="sequential")

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/__init__.py

@@ -0,0 +1,24 @@
+""" The ``sympy.codegen`` module contains classes and functions for building
+abstract syntax trees of algorithms. These trees may then be printed by the
+code-printers in ``sympy.printing``.
+
+There are several submodules available:
+- ``sympy.codegen.ast``: AST nodes useful across multiple languages.
+- ``sympy.codegen.cnodes``: AST nodes useful for the C family of languages.
+- ``sympy.codegen.fnodes``: AST nodes useful for Fortran.
+- ``sympy.codegen.cfunctions``: functions specific to C (C99 math functions)
+- ``sympy.codegen.ffunctions``: functions specific to Fortran (e.g. ``kind``).
+
+
+
+"""
+from .ast import (
+    Assignment, aug_assign, CodeBlock, For, Attribute, Variable, Declaration,
+    While, Scope, Print, FunctionPrototype, FunctionDefinition, FunctionCall
+)
+
+__all__ = [
+    'Assignment', 'aug_assign', 'CodeBlock', 'For', 'Attribute', 'Variable',
+    'Declaration', 'While', 'Scope', 'Print', 'FunctionPrototype',
+    'FunctionDefinition', 'FunctionCall',
+]

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/tests/test_algorithms.py

@@ -0,0 +1,179 @@
+import tempfile
+from sympy import log, Min, Max, sqrt
+from sympy.core.numbers import Float
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.trigonometric import cos
+from sympy.codegen.ast import Assignment, Raise, RuntimeError_, QuotedString
+from sympy.codegen.algorithms import newtons_method, newtons_method_function
+from sympy.codegen.cfunctions import expm1
+from sympy.codegen.fnodes import bind_C
+from sympy.codegen.futils import render_as_module as f_module
+from sympy.codegen.pyutils import render_as_module as py_module
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.utilities._compilation import compile_link_import_strings, has_c, has_fortran
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, raises
+
+cython = import_module('cython')
+wurlitzer = import_module('wurlitzer')
+
+def test_newtons_method():
+    x, dx, atol = symbols('x dx atol')
+    expr = cos(x) - x**3
+    algo = newtons_method(expr, x, atol, dx)
+    assert algo.has(Assignment(dx, -expr/expr.diff(x)))
+
+
+@may_xfail
+def test_newtons_method_function__ccode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.c', ('#include <math.h>\n'
+                          '#include <stdio.h>\n') + ccode(func)),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double)\n"
+                             "def py_newton(x):\n"
+                             "    return newton(x)\n"))
+        ], build_dir=folder, compile_kwargs=compile_kw)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+@may_xfail
+def test_newtons_method_function__fcode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x, attrs=[bind_C(name='newton')])
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_fortran():
+        skip("No Fortran compiler found.")
+
+    f_mod = f_module([func], 'mod_newton')
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.f90', f_mod),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double*)\n"
+                             "def py_newton(double x):\n"
+                             "    return newton(&x)\n"))
+        ], build_dir=folder)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+def test_newtons_method_function__pycode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+    py_mod = py_module(func)
+    namespace = {}
+    exec(py_mod, namespace, namespace)
+    res = eval('newton(0.5)', namespace)
+    assert abs(res - 0.865474033102) < 1e-12
+
+
+@may_xfail
+def test_newtons_method_function__ccode_parameters():
+    args = x, A, k, p = symbols('x A k p')
+    expr = A*cos(k*x) - p*x**3
+    raises(ValueError, lambda: newtons_method_function(expr, x))
+    use_wurlitzer = wurlitzer
+
+    func = newtons_method_function(expr, x, args, debug=use_wurlitzer)
+
+    if not has_c():
+        skip("No C compiler found.")
+    if not cython:
+        skip("cython not installed.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton_par.c', ('#include <math.h>\n'
+                          '#include <stdio.h>\n') + ccode(func)),
+            ('_newton_par.pyx', ("#cython: language_level={}\n".format("3") +
+                                 "cdef extern double newton(double, double, double, double)\n"
+                             "def py_newton(x, A=1, k=1, p=1):\n"
+                             "    return newton(x, A, k, p)\n"))
+        ], compile_kwargs=compile_kw, build_dir=folder)
+
+        if use_wurlitzer:
+            with wurlitzer.pipes() as (out, err):
+                result = mod.py_newton(0.5)
+        else:
+            result = mod.py_newton(0.5)
+
+        assert abs(result - 0.865474033102) < 1e-12
+
+        if not use_wurlitzer:
+            skip("C-level output only tested when package 'wurlitzer' is available.")
+
+        out, err = out.read(), err.read()
+        assert err == ''
+        assert out == """\
+x=         0.5
+x=      1.1121 d_x=     0.61214
+x=     0.90967 d_x=    -0.20247
+x=     0.86726 d_x=   -0.042409
+x=     0.86548 d_x=  -0.0017867
+x=     0.86547 d_x= -3.1022e-06
+x=     0.86547 d_x= -9.3421e-12
+x=     0.86547 d_x=  3.6902e-17
+"""  # try to run tests with LC_ALL=C if this assertion fails
+
+
+def test_newtons_method_function__rtol_cse_nan():
+    a, b, c, N_geo, N_tot = symbols('a b c N_geo N_tot', real=True, nonnegative=True)
+    i = Symbol('i', integer=True, nonnegative=True)
+    N_ari = N_tot - N_geo - 1
+    delta_ari = (c-b)/N_ari
+    ln_delta_geo = log(b) + log(-expm1((log(a)-log(b))/N_geo))
+    eqb_log = ln_delta_geo - log(delta_ari)
+
+    def _clamp(low, expr, high):
+        return Min(Max(low, expr), high)
+
+    meth_kw = {
+        'clamped_newton': {'delta_fn': lambda e, x: _clamp(
+            (sqrt(a*x)-x)*0.99,
+            -e/e.diff(x),
+            (sqrt(c*x)-x)*0.99
+        )},
+        'halley': {'delta_fn': lambda e, x: (-2*(e*e.diff(x))/(2*e.diff(x)**2 - e*e.diff(x, 2)))},
+        'halley_alt': {'delta_fn': lambda e, x: (-e/e.diff(x)/(1-e/e.diff(x)*e.diff(x,2)/2/e.diff(x)))},
+    }
+    args = eqb_log, b
+    for use_cse in [False, True]:
+        kwargs = {
+            'params': (b, a, c, N_geo, N_tot), 'itermax': 60, 'debug': True, 'cse': use_cse,
+            'counter': i, 'atol': 1e-100, 'rtol': 2e-16, 'bounds': (a,c),
+            'handle_nan': Raise(RuntimeError_(QuotedString("encountered NaN.")))
+        }
+        func = {k: newtons_method_function(*args, func_name=f"{k}_b", **dict(kwargs, **kw)) for k, kw in meth_kw.items()}
+        py_mod = {k: py_module(v) for k, v in func.items()}
+        namespace = {}
+        root_find_b = {}
+        for k, v in py_mod.items():
+            ns = namespace[k] = {}
+            exec(v, ns, ns)
+            root_find_b[k] = ns[f'{k}_b']
+        ref = Float('13.2261515064168768938151923226496')
+        reftol = {'clamped_newton': 2e-16, 'halley': 2e-16, 'halley_alt': 3e-16}
+        guess = 4.0
+        for meth, func in root_find_b.items():
+            result = func(guess, 1e-2, 1e2, 50, 100)
+            req = ref*reftol[meth]
+            if use_cse:
+                req *= 2
+            assert abs(result - ref) < req

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/tests/test_cxxnodes.py

@@ -0,0 +1,14 @@
+from sympy.core.symbol import Symbol
+from sympy.codegen.ast import Type
+from sympy.codegen.cxxnodes import using
+from sympy.printing.codeprinter import cxxcode
+
+x = Symbol('x')
+
+def test_using():
+    v = Type('std::vector')
+    u1 = using(v)
+    assert cxxcode(u1) == 'using std::vector'
+
+    u2 = using(v, 'vec')
+    assert cxxcode(u2) == 'using vec = std::vector'

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/tests/test_matrix_nodes.py

@@ -0,0 +1,50 @@
+from sympy.core.symbol import symbols
+from sympy.core.function import Function
+from sympy.matrices.dense import Matrix
+from sympy.matrices.dense import zeros
+from sympy.simplify.simplify import simplify
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.utilities.lambdify import lambdify
+from sympy.printing.numpy import NumPyPrinter
+from sympy.testing.pytest import skip
+from sympy.external import import_module
+
+
+def test_matrix_solve_issue_24862():
+    A = Matrix(3, 3, symbols('a:9'))
+    b = Matrix(3, 1, symbols('b:3'))
+    hash(MatrixSolve(A, b))
+
+
+def test_matrix_solve_derivative_exact():
+    q = symbols('q')
+    a11, a12, a21, a22, b1, b2 = (
+        f(q) for f in symbols('a11 a12 a21 a22 b1 b2', cls=Function))
+    A = Matrix([[a11, a12], [a21, a22]])
+    b = Matrix([b1, b2])
+    x_lu = A.LUsolve(b)
+    dxdq_lu = A.LUsolve(b.diff(q) - A.diff(q) * A.LUsolve(b))
+    assert simplify(x_lu.diff(q) - dxdq_lu) == zeros(2, 1)
+    # dxdq_ms is the MatrixSolve equivalent of dxdq_lu
+    dxdq_ms = MatrixSolve(A, b.diff(q) - A.diff(q) * MatrixSolve(A, b))
+    assert MatrixSolve(A, b).diff(q) == dxdq_ms
+
+
+def test_matrix_solve_derivative_numpy():
+    np = import_module('numpy')
+    if not np:
+        skip("numpy not installed.")
+    q = symbols('q')
+    a11, a12, a21, a22, b1, b2 = (
+        f(q) for f in symbols('a11 a12 a21 a22 b1 b2', cls=Function))
+    A = Matrix([[a11, a12], [a21, a22]])
+    b = Matrix([b1, b2])
+    dx_lu = A.LUsolve(b).diff(q)
+    subs = {a11.diff(q): 0.2, a12.diff(q): 0.3, a21.diff(q): 0.1,
+            a22.diff(q): 0.5, b1.diff(q): 0.4, b2.diff(q): 0.9,
+            a11: 1.3, a12: 0.5, a21: 1.2, a22: 4, b1: 6.2, b2: 3.5}
+    p, p_vals = zip(*subs.items())
+    dx_sm = MatrixSolve(A, b).diff(q)
+    np.testing.assert_allclose(
+        lambdify(p, dx_sm, printer=NumPyPrinter)(*p_vals),
+        lambdify(p, dx_lu, printer=NumPyPrinter)(*p_vals))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/codegen/tests/test_scipy_nodes.py

@@ -0,0 +1,44 @@
+from itertools import product
+from sympy.core.power import Pow
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.trigonometric import cos
+from sympy.core.numbers import pi
+from sympy.codegen.scipy_nodes import cosm1, powm1
+
+x, y, z = symbols('x y z')
+
+
+def test_cosm1():
+    cm1_xy = cosm1(x*y)
+    ref_xy = cos(x*y) - 1
+    for wrt, deriv_order in product([x, y, z], range(3)):
+        assert (
+            cm1_xy.diff(wrt, deriv_order) -
+            ref_xy.diff(wrt, deriv_order)
+        ).rewrite(cos).simplify() == 0
+
+    expr_minus2 = cosm1(pi)
+    assert expr_minus2.rewrite(cos) == -2
+    assert cosm1(3.14).simplify() == cosm1(3.14)  # cannot simplify with 3.14
+    assert cosm1(pi/2).simplify() == -1
+    assert (1/cos(x) - 1 + cosm1(x)/cos(x)).simplify() == 0
+
+
+def test_powm1():
+    cases = {
+            powm1(x, y): x**y - 1,
+            powm1(x*y, z): (x*y)**z - 1,
+            powm1(x, y*z): x**(y*z)-1,
+            powm1(x*y*z, x*y*z): (x*y*z)**(x*y*z)-1
+    }
+    for pm1_e, ref_e in cases.items():
+        for wrt, deriv_order in product([x, y, z], range(3)):
+            der = pm1_e.diff(wrt, deriv_order)
+            ref = ref_e.diff(wrt, deriv_order)
+            delta = (der - ref).rewrite(Pow)
+            assert delta.simplify() == 0
+
+    eulers_constant_m1 = powm1(x, 1/log(x))
+    assert eulers_constant_m1.rewrite(Pow) == exp(1) - 1
+    assert eulers_constant_m1.simplify() == exp(1) - 1

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/tests/test_delta.py

@@ -0,0 +1,499 @@
+from sympy.concrete import Sum
+from sympy.concrete.delta import deltaproduct as dp, deltasummation as ds, _extract_delta
+from sympy.core import Eq, S, symbols, oo
+from sympy.functions import KroneckerDelta as KD, Piecewise, piecewise_fold
+from sympy.logic import And
+from sympy.testing.pytest import raises
+
+i, j, k, l, m = symbols("i j k l m", integer=True, finite=True)
+x, y = symbols("x y", commutative=False)
+
+
+def test_deltaproduct_trivial():
+    assert dp(x, (j, 1, 0)) == 1
+    assert dp(x, (j, 1, 3)) == x**3
+    assert dp(x + y, (j, 1, 3)) == (x + y)**3
+    assert dp(x*y, (j, 1, 3)) == (x*y)**3
+    assert dp(KD(i, j), (k, 1, 3)) == KD(i, j)
+    assert dp(x*KD(i, j), (k, 1, 3)) == x**3*KD(i, j)
+    assert dp(x*y*KD(i, j), (k, 1, 3)) == (x*y)**3*KD(i, j)
+
+
+def test_deltaproduct_basic():
+    assert dp(KD(i, j), (j, 1, 3)) == 0
+    assert dp(KD(i, j), (j, 1, 1)) == KD(i, 1)
+    assert dp(KD(i, j), (j, 2, 2)) == KD(i, 2)
+    assert dp(KD(i, j), (j, 3, 3)) == KD(i, 3)
+    assert dp(KD(i, j), (j, 1, k)) == KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(KD(i, j), (j, k, 3)) == KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(KD(i, j), (j, k, l)) == KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_x_kd():
+    assert dp(x*KD(i, j), (j, 1, 3)) == 0
+    assert dp(x*KD(i, j), (j, 1, 1)) == x*KD(i, 1)
+    assert dp(x*KD(i, j), (j, 2, 2)) == x*KD(i, 2)
+    assert dp(x*KD(i, j), (j, 3, 3)) == x*KD(i, 3)
+    assert dp(x*KD(i, j), (j, 1, k)) == x*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(x*KD(i, j), (j, k, 3)) == x*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(x*KD(i, j), (j, k, l)) == x*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_add_x_y_kd():
+    assert dp((x + y)*KD(i, j), (j, 1, 3)) == 0
+    assert dp((x + y)*KD(i, j), (j, 1, 1)) == (x + y)*KD(i, 1)
+    assert dp((x + y)*KD(i, j), (j, 2, 2)) == (x + y)*KD(i, 2)
+    assert dp((x + y)*KD(i, j), (j, 3, 3)) == (x + y)*KD(i, 3)
+    assert dp((x + y)*KD(i, j), (j, 1, k)) == \
+        (x + y)*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp((x + y)*KD(i, j), (j, k, 3)) == \
+        (x + y)*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp((x + y)*KD(i, j), (j, k, l)) == \
+        (x + y)*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_add_kd_kd():
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 3)) == 0
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 1)) == KD(i, 1) + KD(j, 1)
+    assert dp(KD(i, k) + KD(j, k), (k, 2, 2)) == KD(i, 2) + KD(j, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, 3, 3)) == KD(i, 3) + KD(j, 3)
+    assert dp(KD(i, k) + KD(j, k), (k, 1, l)) == KD(l, 0) + \
+        KD(i, 1)*KD(l, 1) + KD(j, 1)*KD(l, 1) + \
+        KD(i, 1)*KD(j, 2)*KD(l, 2) + KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, 3)) == KD(l, 4) + \
+        KD(i, 3)*KD(l, 3) + KD(j, 3)*KD(l, 3) + \
+        KD(i, 2)*KD(j, 3)*KD(l, 2) + KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, m)) == KD(l, m + 1) + \
+        KD(i, m)*KD(l, m) + KD(j, m)*KD(l, m) + \
+        KD(i, m)*KD(j, m - 1)*KD(l, m - 1) + KD(i, m - 1)*KD(j, m)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_x_add_kd_kd():
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == x*(KD(i, 1) + KD(j, 1))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == x*(KD(i, 2) + KD(j, 2))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == x*(KD(i, 3) + KD(j, 3))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        x*KD(i, 1)*KD(l, 1) + x*KD(j, 1)*KD(l, 1) + \
+        x**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + x**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        x*KD(i, 3)*KD(l, 3) + x*KD(j, 3)*KD(l, 3) + \
+        x**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + x**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        x*KD(i, m)*KD(l, m) + x*KD(j, m)*KD(l, m) + \
+        x**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        x**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_add_x_y_add_kd_kd():
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == \
+        (x + y)*(KD(i, 1) + KD(j, 1))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == \
+        (x + y)*(KD(i, 2) + KD(j, 2))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == \
+        (x + y)*(KD(i, 3) + KD(j, 3))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        (x + y)*KD(i, 1)*KD(l, 1) + (x + y)*KD(j, 1)*KD(l, 1) + \
+        (x + y)**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + \
+        (x + y)**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        (x + y)*KD(i, 3)*KD(l, 3) + (x + y)*KD(j, 3)*KD(l, 3) + \
+        (x + y)**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + \
+        (x + y)**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        (x + y)*KD(i, m)*KD(l, m) + (x + y)*KD(j, m)*KD(l, m) + \
+        (x + y)**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        (x + y)**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_add_mul_x_y_mul_x_kd():
+    assert dp(x*y + x*KD(i, j), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, 1)) == x*y + x*KD(i, 1)
+    assert dp(x*y + x*KD(i, j), (j, 2, 2)) == x*y + x*KD(i, 2)
+    assert dp(x*y + x*KD(i, j), (j, 3, 3)) == x*y + x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, 3)) == \
+        (x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, l)) == \
+        (x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )
+
+
+def test_deltaproduct_mul_x_add_y_kd():
+    assert dp(x*(y + KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + KD(i, j)), (j, 1, 1)) == x*(y + KD(i, 1))
+    assert dp(x*(y + KD(i, j)), (j, 2, 2)) == x*(y + KD(i, 2))
+    assert dp(x*(y + KD(i, j)), (j, 3, 3)) == x*(y + KD(i, 3))
+    assert dp(x*(y + KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_x_add_y_twokd():
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        2*x*(x*y)**2*KD(i, 1) + 2*x*y*x*x*y*KD(i, 2) + 2*(x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 1)) == x*(y + 2*KD(i, 1))
+    assert dp(x*(y + 2*KD(i, j)), (j, 2, 2)) == x*(y + 2*KD(i, 2))
+    assert dp(x*(y + 2*KD(i, j)), (j, 3, 3)) == x*(y + 2*KD(i, 3))
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            (2*(x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_add_x_y_add_y_kd():
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 3)) == ((x + y)*y)**3 + \
+        (x + y)*((x + y)*y)**2*KD(i, 1) + \
+        (x + y)*y*(x + y)**2*y*KD(i, 2) + \
+        ((x + y)*y)**2*(x + y)*KD(i, 3)
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 1)) == (x + y)*(y + KD(i, 1))
+    assert dp((x + y)*(y + KD(i, j)), (j, 2, 2)) == (x + y)*(y + KD(i, 2))
+    assert dp((x + y)*(y + KD(i, j)), (j, 3, 3)) == (x + y)*(y + KD(i, 3))
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, k)) == \
+        ((x + y)*y)**k + Piecewise(
+            (((x + y)*y)**(-1)*((x + y)*y)**i*(x + y)*((x + y)*y
+            )**k*((x + y)*y)**(-i), (i >= 1) & (i <= k)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, 3)) == (
+        (x + y)*y)**4*((x + y)*y)**(-k) + Piecewise((((x + y)*y)**i*(
+        (x + y)*y)**(-k)*(x + y)*((x + y)*y)**3*((x + y)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, l)) == \
+        (x + y)*y*((x + y)*y)**l*((x + y)*y)**(-k) + Piecewise(
+        (((x + y)*y)**i*((x + y)*y)**(-k)*(x + y)*((x + y)*y
+        )**l*((x + y)*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltaproduct_mul_add_x_kd_add_y_kd():
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == \
+        KD(i, 1)*(KD(i, k) + x)*((KD(i, k) + x)*y)**2 + \
+        KD(i, 2)*(KD(i, k) + x)*y*(KD(i, k) + x)**2*y + \
+        KD(i, 3)*((KD(i, k) + x)*y)**2*(KD(i, k) + x) + \
+        ((KD(i, k) + x)*y)**3
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == \
+        (x + KD(i, k))*(y + KD(i, 1))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == \
+        (x + KD(i, k))*(y + KD(i, 2))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == \
+        (x + KD(i, k))*(y + KD(i, 3))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == \
+        ((KD(i, k) + x)*y)**k + Piecewise(
+        (((KD(i, k) + x)*y)**(-1)*((KD(i, k) + x)*y)**i*(KD(i, k) + x
+        )*((KD(i, k) + x)*y)**k*((KD(i, k) + x)*y)**(-i), (i >= 1
+        ) & (i <= k)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == (
+        (KD(i, k) + x)*y)**4*((KD(i, k) + x)*y)**(-k) + Piecewise(
+        (((KD(i, k) + x)*y)**i*((KD(i, k) + x)*y)**(-k)*(KD(i, k)
+        + x)*((KD(i, k) + x)*y)**3*((KD(i, k) + x)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == (
+        KD(i, k) + x)*y*((KD(i, k) + x)*y)**l*((KD(i, k) + x)*y
+        )**(-k) + Piecewise((((KD(i, k) + x)*y)**i*((KD(i, k) + x
+        )*y)**(-k)*(KD(i, k) + x)*((KD(i, k) + x)*y)**l*((KD(i, k) + x
+        )*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltasummation_trivial():
+    assert ds(x, (j, 1, 0)) == 0
+    assert ds(x, (j, 1, 3)) == 3*x
+    assert ds(x + y, (j, 1, 3)) == 3*(x + y)
+    assert ds(x*y, (j, 1, 3)) == 3*x*y
+    assert ds(KD(i, j), (k, 1, 3)) == 3*KD(i, j)
+    assert ds(x*KD(i, j), (k, 1, 3)) == 3*x*KD(i, j)
+    assert ds(x*y*KD(i, j), (k, 1, 3)) == 3*x*y*KD(i, j)
+
+
+def test_deltasummation_basic_numerical():
+    n = symbols('n', integer=True, nonzero=True)
+    assert ds(KD(n, 0), (n, 1, 3)) == 0
+
+    # return unevaluated, until it gets implemented
+    assert ds(KD(i**2, j**2), (j, -oo, oo)) == \
+        Sum(KD(i**2, j**2), (j, -oo, oo))
+
+    assert Piecewise((KD(i, k), And(1 <= i, i <= 3)), (0, True)) == \
+        ds(KD(i, j)*KD(j, k), (j, 1, 3)) == \
+        ds(KD(j, k)*KD(i, j), (j, 1, 3))
+
+    assert ds(KD(i, k), (k, -oo, oo)) == 1
+    assert ds(KD(i, k), (k, 0, oo)) == Piecewise((1, S.Zero <= i), (0, True))
+    assert ds(KD(i, k), (k, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(k*KD(i, j)*KD(j, k), (k, -oo, oo)) == j*KD(i, j)
+    assert ds(j*KD(i, j), (j, -oo, oo)) == i
+    assert ds(i*KD(i, j), (i, -oo, oo)) == j
+    assert ds(x, (i, 1, 3)) == 3*x
+    assert ds((i + j)*KD(i, j), (j, -oo, oo)) == 2*i
+
+
+def test_deltasummation_basic_symbolic():
+    assert ds(KD(i, j), (j, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, 1)) == Piecewise((1, Eq(i, 1)), (0, True))
+    assert ds(KD(i, j), (j, 2, 2)) == Piecewise((1, Eq(i, 2)), (0, True))
+    assert ds(KD(i, j), (j, 3, 3)) == Piecewise((1, Eq(i, 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, k)) == \
+        Piecewise((1, And(1 <= i, i <= k)), (0, True))
+    assert ds(KD(i, j), (j, k, 3)) == \
+        Piecewise((1, And(k <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, k, l)) == \
+        Piecewise((1, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_x_kd():
+    assert ds(x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, 1)) == Piecewise((x, Eq(i, 1)), (0, True))
+    assert ds(x*KD(i, j), (j, 2, 2)) == Piecewise((x, Eq(i, 2)), (0, True))
+    assert ds(x*KD(i, j), (j, 3, 3)) == Piecewise((x, Eq(i, 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, k)) == \
+        Piecewise((x, And(1 <= i, i <= k)), (0, True))
+    assert ds(x*KD(i, j), (j, k, 3)) == \
+        Piecewise((x, And(k <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, k, l)) == \
+        Piecewise((x, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_add_x_y_kd():
+    assert ds((x + y)*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x + y, Eq(i, 1)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x + y, Eq(i, 2)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x + y, Eq(i, 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, k)) == \
+        Piecewise((x + y, And(1 <= i, i <= k)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, 3)) == \
+        Piecewise((x + y, And(k <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, l)) == \
+        Piecewise((x + y, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_add_kd_kd():
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((1, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((1, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((1, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_kd_kd():
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_x_add_kd_kd():
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((x, Eq(j, 1)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((x, Eq(j, 2)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((x, Eq(j, 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_add_x_y_add_kd_kd():
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 1)), (0, True)) +
+        Piecewise((x + y, Eq(j, 1)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 2)), (0, True)) +
+        Piecewise((x + y, Eq(j, 2)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 3)), (0, True)) +
+        Piecewise((x + y, Eq(j, 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= l)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_y_mul_x_kd():
+    assert ds(x*y + x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_kd():
+    assert ds(x*(y + KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_twokd():
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + 2*x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + 2*x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + 2*x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + 2*x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + 2*x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*x*y + 2*x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + 2*x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_add_x_y_add_y_kd():
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 3)) == Piecewise(
+        (3*(x + y)*y + x + y, And(1 <= i, i <= 3)), (3*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 1)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 2)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 3)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, k)) == Piecewise(
+        (k*(x + y)*y + x + y, And(1 <= i, i <= k)), (k*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*(x + y)*y + x + y, And(k <= i, i <= 3)),
+        ((4 - k)*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*(x + y)*y + x + y, And(k <= i, i <= l)),
+        ((l - k + 1)*(x + y)*y, True))
+
+
+def test_deltasummation_mul_add_x_kd_add_y_kd():
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= 3)), (0, True)) +
+        3*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 1)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 2)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 3)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= k)), (0, True)) +
+        k*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= 3)), (0, True)) +
+        (4 - k)*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= l)), (0, True)) +
+        (l - k + 1)*(KD(i, k) + x)*y)
+
+
+def test_extract_delta():
+    raises(ValueError, lambda: _extract_delta(KD(i, j) + KD(k, l), i))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/tests/test_products.py

@@ -0,0 +1,410 @@
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (rf, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.simplify import simplify
+from sympy.testing.pytest import raises
+
+a, k, n, m, x = symbols('a,k,n,m,x', integer=True)
+f = Function('f')
+
+
+def test_karr_convention():
+    # Test the Karr product convention that we want to hold.
+    # See his paper "Summation in Finite Terms" for a detailed
+    # reasoning why we really want exactly this definition.
+    # The convention is described for sums on page 309 and
+    # essentially in section 1.4, definition 3. For products
+    # we can find in analogy:
+    #
+    # \prod_{m <= i < n} f(i) 'has the obvious meaning'      for m < n
+    # \prod_{m <= i < n} f(i) = 0                            for m = n
+    # \prod_{m <= i < n} f(i) = 1 / \prod_{n <= i < m} f(i)  for m > n
+    #
+    # It is important to note that he defines all products with
+    # the upper limit being *exclusive*.
+    # In contrast, SymPy and the usual mathematical notation has:
+    #
+    # prod_{i = a}^b f(i) = f(a) * f(a+1) * ... * f(b-1) * f(b)
+    #
+    # with the upper limit *inclusive*. So translating between
+    # the two we find that:
+    #
+    # \prod_{m <= i < n} f(i) = \prod_{i = m}^{n-1} f(i)
+    #
+    # where we intentionally used two different ways to typeset the
+    # products and its limits.
+
+    i = Symbol("i", integer=True)
+    k = Symbol("k", integer=True)
+    j = Symbol("j", integer=True, positive=True)
+
+    # A simple example with a concrete factors and symbolic limits.
+
+    # The normal product: m = k and n = k + j and therefore m < n:
+    m = k
+    n = k + j
+
+    a = m
+    b = n - 1
+    S1 = Product(i**2, (i, a, b)).doit()
+
+    # The reversed product: m = k + j and n = k and therefore m > n:
+    m = k + j
+    n = k
+
+    a = m
+    b = n - 1
+    S2 = Product(i**2, (i, a, b)).doit()
+
+    assert S1 * S2 == 1
+
+    # Test the empty product: m = k and n = k and therefore m = n:
+    m = k
+    n = k
+
+    a = m
+    b = n - 1
+    Sz = Product(i**2, (i, a, b)).doit()
+
+    assert Sz == 1
+
+    # Another example this time with an unspecified factor and
+    # numeric limits. (We can not do both tests in the same example.)
+    f = Function("f")
+
+    # The normal product with m < n:
+    m = 2
+    n = 11
+
+    a = m
+    b = n - 1
+    S1 = Product(f(i), (i, a, b)).doit()
+
+    # The reversed product with m > n:
+    m = 11
+    n = 2
+
+    a = m
+    b = n - 1
+    S2 = Product(f(i), (i, a, b)).doit()
+
+    assert simplify(S1 * S2) == 1
+
+    # Test the empty product with m = n:
+    m = 5
+    n = 5
+
+    a = m
+    b = n - 1
+    Sz = Product(f(i), (i, a, b)).doit()
+
+    assert Sz == 1
+
+
+def test_karr_proposition_2a():
+    # Test Karr, page 309, proposition 2, part a
+    i, u, v = symbols('i u v', integer=True)
+
+    def test_the_product(m, n):
+        # g
+        g = i**3 + 2*i**2 - 3*i
+        # f = Delta g
+        f = simplify(g.subs(i, i+1) / g)
+        # The product
+        a = m
+        b = n - 1
+        P = Product(f, (i, a, b)).doit()
+        # Test if Product_{m <= i < n} f(i) = g(n) / g(m)
+        assert combsimp(P / (g.subs(i, n) / g.subs(i, m))) == 1
+
+    # m < n
+    test_the_product(u, u + v)
+    # m = n
+    test_the_product(u, u)
+    # m > n
+    test_the_product(u + v, u)
+
+
+def test_karr_proposition_2b():
+    # Test Karr, page 309, proposition 2, part b
+    i, u, v, w = symbols('i u v w', integer=True)
+
+    def test_the_product(l, n, m):
+        # Productmand
+        s = i**3
+        # First product
+        a = l
+        b = n - 1
+        S1 = Product(s, (i, a, b)).doit()
+        # Second product
+        a = l
+        b = m - 1
+        S2 = Product(s, (i, a, b)).doit()
+        # Third product
+        a = m
+        b = n - 1
+        S3 = Product(s, (i, a, b)).doit()
+        # Test if S1 = S2 * S3 as required
+        assert combsimp(S1 / (S2 * S3)) == 1
+
+    # l < m < n
+    test_the_product(u, u + v, u + v + w)
+    # l < m = n
+    test_the_product(u, u + v, u + v)
+    # l < m > n
+    test_the_product(u, u + v + w, v)
+    # l = m < n
+    test_the_product(u, u, u + v)
+    # l = m = n
+    test_the_product(u, u, u)
+    # l = m > n
+    test_the_product(u + v, u + v, u)
+    # l > m < n
+    test_the_product(u + v, u, u + w)
+    # l > m = n
+    test_the_product(u + v, u, u)
+    # l > m > n
+    test_the_product(u + v + w, u + v, u)
+
+
+def test_simple_products():
+    assert product(2, (k, a, n)) == 2**(n - a + 1)
+    assert product(k, (k, 1, n)) == factorial(n)
+    assert product(k**3, (k, 1, n)) == factorial(n)**3
+
+    assert product(k + 1, (k, 0, n - 1)) == factorial(n)
+    assert product(k + 1, (k, a, n - 1)) == rf(1 + a, n - a)
+
+    assert product(cos(k), (k, 0, 5)) == cos(1)*cos(2)*cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 3, 5)) == cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 1, Rational(5, 2))) != cos(1)*cos(2)
+
+    assert isinstance(product(k**k, (k, 1, n)), Product)
+
+    assert Product(x**k, (k, 1, n)).variables == [k]
+
+    raises(ValueError, lambda: Product(n))
+    raises(ValueError, lambda: Product(n, k))
+    raises(ValueError, lambda: Product(n, k, 1))
+    raises(ValueError, lambda: Product(n, k, 1, 10))
+    raises(ValueError, lambda: Product(n, (k, 1)))
+
+    assert product(1, (n, 1, oo)) == 1  # issue 8301
+    assert product(2, (n, 1, oo)) is oo
+    assert product(-1, (n, 1, oo)).func is Product
+
+
+def test_multiple_products():
+    assert product(x, (n, 1, k), (k, 1, m)) == x**(m**2/2 + m/2)
+    assert product(f(n), (
+        n, 1, m), (m, 1, k)) == Product(f(n), (n, 1, m), (m, 1, k)).doit()
+    assert Product(f(n), (m, 1, k), (n, 1, k)).doit() == \
+        Product(Product(f(n), (m, 1, k)), (n, 1, k)).doit() == \
+        product(f(n), (m, 1, k), (n, 1, k)) == \
+        product(product(f(n), (m, 1, k)), (n, 1, k)) == \
+        Product(f(n)**k, (n, 1, k))
+    assert Product(
+        x, (x, 1, k), (k, 1, n)).doit() == Product(factorial(k), (k, 1, n))
+
+    assert Product(x**k, (n, 1, k), (k, 1, m)).variables == [n, k]
+
+
+def test_rational_products():
+    assert product(1 + 1/k, (k, 1, n)) == rf(2, n)/factorial(n)
+
+
+def test_special_products():
+    # Wallis product
+    assert product((4*k)**2 / (4*k**2 - 1), (k, 1, n)) == \
+        4**n*factorial(n)**2/rf(S.Half, n)/rf(Rational(3, 2), n)
+
+    # Euler's product formula for sin
+    assert product(1 + a/k**2, (k, 1, n)) == \
+        rf(1 - sqrt(-a), n)*rf(1 + sqrt(-a), n)/factorial(n)**2
+
+
+def test__eval_product():
+    from sympy.abc import i, n
+    # issue 4809
+    a = Function('a')
+    assert product(2*a(i), (i, 1, n)) == 2**n * Product(a(i), (i, 1, n))
+    # issue 4810
+    assert product(2**i, (i, 1, n)) == 2**(n*(n + 1)/2)
+    k, m = symbols('k m', integer=True)
+    assert product(2**i, (i, k, m)) == 2**(-k**2/2 + k/2 + m**2/2 + m/2)
+    n = Symbol('n', negative=True, integer=True)
+    p = Symbol('p', positive=True, integer=True)
+    assert product(2**i, (i, n, p)) == 2**(-n**2/2 + n/2 + p**2/2 + p/2)
+    assert product(2**i, (i, p, n)) == 2**(n**2/2 + n/2 - p**2/2 + p/2)
+
+
+def test_product_pow():
+    # issue 4817
+    assert product(2**f(k), (k, 1, n)) == 2**Sum(f(k), (k, 1, n))
+    assert product(2**(2*f(k)), (k, 1, n)) == 2**Sum(2*f(k), (k, 1, n))
+
+
+def test_infinite_product():
+    # issue 5737
+    assert isinstance(Product(2**(1/factorial(n)), (n, 0, oo)), Product)
+
+
+def test_conjugate_transpose():
+    p = Product(x**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    A, B = symbols("A B", commutative=False)
+    p = Product(A*B**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    p = Product(B**k*A, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+
+def test_simplify_prod():
+    y, t, b, c, v, d = symbols('y, t, b, c, v, d', integer = True)
+
+    _simplify = lambda e: simplify(e, doit=False)
+    assert _simplify(Product(x*y, (x, n, m), (y, a, k)) * \
+        Product(y, (x, n, m), (y, a, k))) == \
+            Product(x*y**2, (x, n, m), (y, a, k))
+    assert _simplify(3 * y* Product(x, (x, n, m)) * Product(x, (x, m + 1, a))) \
+        == 3 * y * Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x, (x, n, k))) == \
+        Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))) == \
+        Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))
+    assert _simplify(Product(x, (t, a, b)) * Product(y, (t, a, b)) * \
+        Product(x, (t, b+1, c))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(x, (t, a, b)) * Product(x, (t, b+1, c)) * \
+        Product(y, (t, a, b))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
+        Product(2, (t, a, b))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 - 1, (t, a, b))) == \
+           Product(0, (t, a, b))
+    assert _simplify(Product(v*Product(sin(t)**2 + cos(t)**2, (t, a, b)),
+                             (v, c, d))) == Product(v*Product(1, (t, a, b)), (v, c, d))
+
+
+def test_change_index():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x, (x, a, b)).change_index(x, x + 1, y) == \
+        Product(y - 1, (y, a + 1, b + 1))
+    assert Product(x**2, (x, a, b)).change_index(x, x - 1) == \
+        Product((x + 1)**2, (x, a - 1, b - 1))
+    assert Product(x**2, (x, a, b)).change_index(x, -x, y) == \
+        Product((-y)**2, (y, -b, -a))
+    assert Product(x, (x, a, b)).change_index(x, -x - 1) == \
+        Product(-x - 1, (x, - b - 1, -a - 1))
+    assert Product(x*y, (x, a, b), (y, c, d)).change_index(x, x - 1, z) == \
+        Product((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
+
+
+def test_reorder():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
+        Product(x, (x, c, d), (x, a, b))
+    assert Product(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
+        (2, 0), (0, 1)) == Product(x*y + z, (z, m, n), (y, c, d), (x, a, b))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (0, 1), (1, 2), (0, 2)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (x, y), (y, z), (x, z)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+
+
+def test_Product_is_convergent():
+    assert Product(1/n**2, (n, 1, oo)).is_convergent() is S.false
+    assert Product(exp(1/n**2), (n, 1, oo)).is_convergent() is S.true
+    assert Product(1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n**2, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_reverse_order():
+    x, y, a, b, c, d= symbols('x, y, a, b, c, d', integer = True)
+
+    assert Product(x, (x, 0, 3)).reverse_order(0) == Product(1/x, (x, 4, -1))
+    assert Product(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
+           Product(x*y, (x, 6, 0), (y, 7, -1))
+    assert Product(x, (x, 1, 2)).reverse_order(0) == Product(1/x, (x, 3, 0))
+    assert Product(x, (x, 1, 3)).reverse_order(0) == Product(1/x, (x, 4, 0))
+    assert Product(x, (x, 1, a)).reverse_order(0) == Product(1/x, (x, a + 1, 0))
+    assert Product(x, (x, a, 5)).reverse_order(0) == Product(1/x, (x, 6, a - 1))
+    assert Product(x, (x, a + 1, a + 5)).reverse_order(0) == \
+           Product(1/x, (x, a + 6, a))
+    assert Product(x, (x, a + 1, a + 2)).reverse_order(0) == \
+           Product(1/x, (x, a + 3, a))
+    assert Product(x, (x, a + 1, a + 1)).reverse_order(0) == \
+           Product(1/x, (x, a + 2, a))
+    assert Product(x, (x, a, b)).reverse_order(0) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x, (x, a, b)).reverse_order(x) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+
+def test_issue_9983():
+    n = Symbol('n', integer=True, positive=True)
+    p = Product(1 + 1/n**Rational(2, 3), (n, 1, oo))
+    assert p.is_convergent() is S.false
+    assert product(1 + 1/n**Rational(2, 3), (n, 1, oo)) == p.doit()
+
+
+def test_issue_13546():
+    n = Symbol('n')
+    k = Symbol('k')
+    p = Product(n + 1 / 2**k, (k, 0, n-1)).doit()
+    assert p.subs(n, 2).doit() == Rational(15, 2)
+
+
+def test_issue_14036():
+    a, n = symbols('a n')
+    assert product(1 - a**2 / (n*pi)**2, [n, 1, oo]) != 0
+
+
+def test_rewrite_Sum():
+    assert Product(1 - S.Half**2/k**2, (k, 1, oo)).rewrite(Sum) == \
+        exp(Sum(log(1 - 1/(4*k**2)), (k, 1, oo)))
+
+
+def test_KroneckerDelta_Product():
+    y = Symbol('y')
+    assert Product(x*KroneckerDelta(x, y), (x, 0, 1)).doit() == 0
+
+
+def test_issue_20848():
+    _i = Dummy('i')
+    t, y, z = symbols('t y z')
+    assert diff(Product(x, (y, 1, z)), x).as_dummy() == Sum(Product(x, (y, 1, _i - 1))*Product(x, (y, _i + 1, z)), (_i, 1, z)).as_dummy()
+    assert diff(Product(x, (y, 1, z)), x).doit() == x**(z - 1)*z
+    assert diff(Product(x, (y, x, z)), x) == Derivative(Product(x, (y, x, z)), x)
+    assert diff(Product(t, (x, 1, z)), x) == S(0)
+    assert Product(sin(n*x), (n, -1, 1)).diff(x).doit() == S(0)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/concrete/tests/test_sums_products.py

@@ -0,0 +1,1646 @@
+from math import prod
+
+from sympy.concrete.expr_with_intlimits import ReorderError
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import (Sum, summation, telescopic,
+     eval_sum_residue, _dummy_with_inherited_properties_concrete)
+from sympy.core.function import (Derivative, Function)
+from sympy.core import (Catalan, EulerGamma)
+from sympy.core.facts import InconsistentAssumptions
+from sympy.core.mod import Mod
+from sympy.core.numbers import (E, I, Rational, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.numbers import Float
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (rf, binomial, factorial)
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (sinh, tanh)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+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, Or
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import Identity
+from sympy.matrices import (Matrix, SparseMatrix,
+    ImmutableDenseMatrix, ImmutableSparseMatrix, diag)
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import Interval
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Idx, Indexed, IndexedBase)
+from sympy.testing.pytest import XFAIL, raises, slow
+from sympy.abc import a, b, c, d, k, m, x, y, z
+
+n = Symbol('n', integer=True)
+f, g = symbols('f g', cls=Function)
+
+def test_karr_convention():
+    # Test the Karr summation convention that we want to hold.
+    # See his paper "Summation in Finite Terms" for a detailed
+    # reasoning why we really want exactly this definition.
+    # The convention is described on page 309 and essentially
+    # in section 1.4, definition 3:
+    #
+    # \sum_{m <= i < n} f(i) 'has the obvious meaning'   for m < n
+    # \sum_{m <= i < n} f(i) = 0                         for m = n
+    # \sum_{m <= i < n} f(i) = - \sum_{n <= i < m} f(i)  for m > n
+    #
+    # It is important to note that he defines all sums with
+    # the upper limit being *exclusive*.
+    # In contrast, SymPy and the usual mathematical notation has:
+    #
+    # sum_{i = a}^b f(i) = f(a) + f(a+1) + ... + f(b-1) + f(b)
+    #
+    # with the upper limit *inclusive*. So translating between
+    # the two we find that:
+    #
+    # \sum_{m <= i < n} f(i) = \sum_{i = m}^{n-1} f(i)
+    #
+    # where we intentionally used two different ways to typeset the
+    # sum and its limits.
+
+    i = Symbol("i", integer=True)
+    k = Symbol("k", integer=True)
+    j = Symbol("j", integer=True)
+
+    # A simple example with a concrete summand and symbolic limits.
+
+    # The normal sum: m = k and n = k + j and therefore m < n:
+    m = k
+    n = k + j
+
+    a = m
+    b = n - 1
+    S1 = Sum(i**2, (i, a, b)).doit()
+
+    # The reversed sum: m = k + j and n = k and therefore m > n:
+    m = k + j
+    n = k
+
+    a = m
+    b = n - 1
+    S2 = Sum(i**2, (i, a, b)).doit()
+
+    assert simplify(S1 + S2) == 0
+
+    # Test the empty sum: m = k and n = k and therefore m = n:
+    m = k
+    n = k
+
+    a = m
+    b = n - 1
+    Sz = Sum(i**2, (i, a, b)).doit()
+
+    assert Sz == 0
+
+    # Another example this time with an unspecified summand and
+    # numeric limits. (We can not do both tests in the same example.)
+
+    # The normal sum with m < n:
+    m = 2
+    n = 11
+
+    a = m
+    b = n - 1
+    S1 = Sum(f(i), (i, a, b)).doit()
+
+    # The reversed sum with m > n:
+    m = 11
+    n = 2
+
+    a = m
+    b = n - 1
+    S2 = Sum(f(i), (i, a, b)).doit()
+
+    assert simplify(S1 + S2) == 0
+
+    # Test the empty sum with m = n:
+    m = 5
+    n = 5
+
+    a = m
+    b = n - 1
+    Sz = Sum(f(i), (i, a, b)).doit()
+
+    assert Sz == 0
+
+    e = Piecewise((exp(-i), Mod(i, 2) > 0), (0, True))
+    s = Sum(e, (i, 0, 11))
+    assert s.n(3) == s.doit().n(3)
+
+
+def test_karr_proposition_2a():
+    # Test Karr, page 309, proposition 2, part a
+    i = Symbol("i", integer=True)
+    u = Symbol("u", integer=True)
+    v = Symbol("v", integer=True)
+
+    def test_the_sum(m, n):
+        # g
+        g = i**3 + 2*i**2 - 3*i
+        # f = Delta g
+        f = simplify(g.subs(i, i+1) - g)
+        # The sum
+        a = m
+        b = n - 1
+        S = Sum(f, (i, a, b)).doit()
+        # Test if Sum_{m <= i < n} f(i) = g(n) - g(m)
+        assert simplify(S - (g.subs(i, n) - g.subs(i, m))) == 0
+
+    # m < n
+    test_the_sum(u,   u+v)
+    # m = n
+    test_the_sum(u,   u  )
+    # m > n
+    test_the_sum(u+v, u  )
+
+
+def test_karr_proposition_2b():
+    # Test Karr, page 309, proposition 2, part b
+    i = Symbol("i", integer=True)
+    u = Symbol("u", integer=True)
+    v = Symbol("v", integer=True)
+    w = Symbol("w", integer=True)
+
+    def test_the_sum(l, n, m):
+        # Summand
+        s = i**3
+        # First sum
+        a = l
+        b = n - 1
+        S1 = Sum(s, (i, a, b)).doit()
+        # Second sum
+        a = l
+        b = m - 1
+        S2 = Sum(s, (i, a, b)).doit()
+        # Third sum
+        a = m
+        b = n - 1
+        S3 = Sum(s, (i, a, b)).doit()
+        # Test if S1 = S2 + S3 as required
+        assert S1 - (S2 + S3) == 0
+
+    # l < m < n
+    test_the_sum(u,     u+v,   u+v+w)
+    # l < m = n
+    test_the_sum(u,     u+v,   u+v  )
+    # l < m > n
+    test_the_sum(u,     u+v+w, v    )
+    # l = m < n
+    test_the_sum(u,     u,     u+v  )
+    # l = m = n
+    test_the_sum(u,     u,     u    )
+    # l = m > n
+    test_the_sum(u+v,   u+v,   u    )
+    # l > m < n
+    test_the_sum(u+v,   u,     u+w  )
+    # l > m = n
+    test_the_sum(u+v,   u,     u    )
+    # l > m > n
+    test_the_sum(u+v+w, u+v,   u    )
+
+
+def test_arithmetic_sums():
+    assert summation(1, (n, a, b)) == b - a + 1
+    assert Sum(S.NaN, (n, a, b)) is S.NaN
+    assert Sum(x, (n, a, a)).doit() == x
+    assert Sum(x, (x, a, a)).doit() == a
+    assert Sum(x, (n, 1, a)).doit() == a*x
+    assert Sum(x, (x, Range(1, 11))).doit() == 55
+    assert Sum(x, (x, Range(1, 11, 2))).doit() == 25
+    assert Sum(x, (x, Range(1, 10, 2))) == Sum(x, (x, Range(9, 0, -2)))
+    lo, hi = 1, 2
+    s1 = Sum(n, (n, lo, hi))
+    s2 = Sum(n, (n, hi, lo))
+    assert s1 != s2
+    assert s1.doit() == 3 and s2.doit() == 0
+    lo, hi = x, x + 1
+    s1 = Sum(n, (n, lo, hi))
+    s2 = Sum(n, (n, hi, lo))
+    assert s1 != s2
+    assert s1.doit() == 2*x + 1 and s2.doit() == 0
+    assert Sum(Integral(x, (x, 1, y)) + x, (x, 1, 2)).doit() == \
+        y**2 + 2
+    assert summation(1, (n, 1, 10)) == 10
+    assert summation(2*n, (n, 0, 10**10)) == 100000000010000000000
+    assert summation(4*n*m, (n, a, 1), (m, 1, d)).expand() == \
+        2*d + 2*d**2 + a*d + a*d**2 - d*a**2 - a**2*d**2
+    assert summation(cos(n), (n, -2, 1)) == cos(-2) + cos(-1) + cos(0) + cos(1)
+    assert summation(cos(n), (n, x, x + 2)) == cos(x) + cos(x + 1) + cos(x + 2)
+    assert isinstance(summation(cos(n), (n, x, x + S.Half)), Sum)
+    assert summation(k, (k, 0, oo)) is oo
+    assert summation(k, (k, Range(1, 11))) == 55
+
+
+def test_polynomial_sums():
+    assert summation(n**2, (n, 3, 8)) == 199
+    assert summation(n, (n, a, b)) == \
+        ((a + b)*(b - a + 1)/2).expand()
+    assert summation(n**2, (n, 1, b)) == \
+        ((2*b**3 + 3*b**2 + b)/6).expand()
+    assert summation(n**3, (n, 1, b)) == \
+        ((b**4 + 2*b**3 + b**2)/4).expand()
+    assert summation(n**6, (n, 1, b)) == \
+        ((6*b**7 + 21*b**6 + 21*b**5 - 7*b**3 + b)/42).expand()
+
+
+def test_geometric_sums():
+    assert summation(pi**n, (n, 0, b)) == (1 - pi**(b + 1)) / (1 - pi)
+    assert summation(2 * 3**n, (n, 0, b)) == 3**(b + 1) - 1
+    assert summation(S.Half**n, (n, 1, oo)) == 1
+    assert summation(2**n, (n, 0, b)) == 2**(b + 1) - 1
+    assert summation(2**n, (n, 1, oo)) is oo
+    assert summation(2**(-n), (n, 1, oo)) == 1
+    assert summation(3**(-n), (n, 4, oo)) == Rational(1, 54)
+    assert summation(2**(-4*n + 3), (n, 1, oo)) == Rational(8, 15)
+    assert summation(2**(n + 1), (n, 1, b)).expand() == 4*(2**b - 1)
+
+    # issue 6664:
+    assert summation(x**n, (n, 0, oo)) == \
+        Piecewise((1/(-x + 1), Abs(x) < 1), (Sum(x**n, (n, 0, oo)), True))
+
+    assert summation(-2**n, (n, 0, oo)) is -oo
+    assert summation(I**n, (n, 0, oo)) == Sum(I**n, (n, 0, oo))
+
+    # issue 6802:
+    assert summation((-1)**(2*x + 2), (x, 0, n)) == n + 1
+    assert summation((-2)**(2*x + 2), (x, 0, n)) == 4*4**(n + 1)/S(3) - Rational(4, 3)
+    assert summation((-1)**x, (x, 0, n)) == -(-1)**(n + 1)/S(2) + S.Half
+    assert summation(y**x, (x, a, b)) == \
+        Piecewise((-a + b + 1, Eq(y, 1)), ((y**a - y**(b + 1))/(-y + 1), True))
+    assert summation((-2)**(y*x + 2), (x, 0, n)) == \
+        4*Piecewise((n + 1, Eq((-2)**y, 1)),
+                    ((-(-2)**(y*(n + 1)) + 1)/(-(-2)**y + 1), True))
+
+    # issue 8251:
+    assert summation((1/(n + 1)**2)*n**2, (n, 0, oo)) is oo
+
+    #issue 9908:
+    assert Sum(1/(n**3 - 1), (n, -oo, -2)).doit() == summation(1/(n**3 - 1), (n, -oo, -2))
+
+    #issue 11642:
+    result = Sum(0.5**n, (n, 1, oo)).doit()
+    assert result == 1.0
+    assert result.is_Float
+
+    result = Sum(0.25**n, (n, 1, oo)).doit()
+    assert result == 1/3.
+    assert result.is_Float
+
+    result = Sum(0.99999**n, (n, 1, oo)).doit()
+    assert result == 99999.0
+    assert result.is_Float
+
+    result = Sum(S.Half**n, (n, 1, oo)).doit()
+    assert result == 1
+    assert not result.is_Float
+
+    result = Sum(Rational(3, 5)**n, (n, 1, oo)).doit()
+    assert result == Rational(3, 2)
+    assert not result.is_Float
+
+    assert Sum(1.0**n, (n, 1, oo)).doit() is oo
+    assert Sum(2.43**n, (n, 1, oo)).doit() is oo
+
+    # Issue 13979
+    i, k, q = symbols('i k q', integer=True)
+    result = summation(
+        exp(-2*I*pi*k*i/n) * exp(2*I*pi*q*i/n) / n, (i, 0, n - 1)
+    )
+    assert result.simplify() == Piecewise(
+            (1, Eq(exp(-2*I*pi*(k - q)/n), 1)), (0, True)
+    )
+
+    #Issue 23491
+    assert Sum(1/(n**2 + 1), (n, 1, oo)).doit() == S(-1)/2 + pi/(2*tanh(pi))
+
+def test_harmonic_sums():
+    assert summation(1/k, (k, 0, n)) == Sum(1/k, (k, 0, n))
+    assert summation(1/k, (k, 1, n)) == harmonic(n)
+    assert summation(n/k, (k, 1, n)) == n*harmonic(n)
+    assert summation(1/k, (k, 5, n)) == harmonic(n) - harmonic(4)
+
+
+def test_composite_sums():
+    f = S.Half*(7 - 6*n + Rational(1, 7)*n**3)
+    s = summation(f, (n, a, b))
+    assert not isinstance(s, Sum)
+    A = 0
+    for i in range(-3, 5):
+        A += f.subs(n, i)
+    B = s.subs(a, -3).subs(b, 4)
+    assert A == B
+
+
+def test_hypergeometric_sums():
+    assert summation(
+        binomial(2*k, k)/4**k, (k, 0, n)) == (1 + 2*n)*binomial(2*n, n)/4**n
+    assert summation(binomial(2*k, k)/5**k, (k, -oo, oo)) == sqrt(5)
+
+
+def test_other_sums():
+    f = m**2 + m*exp(m)
+    g = 3*exp(Rational(3, 2))/2 + exp(S.Half)/2 - exp(Rational(-1, 2))/2 - 3*exp(Rational(-3, 2))/2 + 5
+
+    assert summation(f, (m, Rational(-3, 2), Rational(3, 2))) == g
+    assert summation(f, (m, -1.5, 1.5)).evalf().epsilon_eq(g.evalf(), 1e-10)
+
+fac = factorial
+
+
+def NS(e, n=15, **options):
+    return str(sympify(e).evalf(n, **options))
+
+
+def test_evalf_fast_series():
+    # Euler transformed series for sqrt(1+x)
+    assert NS(Sum(
+        fac(2*n + 1)/fac(n)**2/2**(3*n + 1), (n, 0, oo)), 100) == NS(sqrt(2), 100)
+
+    # Some series for exp(1)
+    estr = NS(E, 100)
+    assert NS(Sum(1/fac(n), (n, 0, oo)), 100) == estr
+    assert NS(1/Sum((1 - 2*n)/fac(2*n), (n, 0, oo)), 100) == estr
+    assert NS(Sum((2*n + 1)/fac(2*n), (n, 0, oo)), 100) == estr
+    assert NS(Sum((4*n + 3)/2**(2*n + 1)/fac(2*n + 1), (n, 0, oo))**2, 100) == estr
+
+    pistr = NS(pi, 100)
+    # Ramanujan series for pi
+    assert NS(9801/sqrt(8)/Sum(fac(
+        4*n)*(1103 + 26390*n)/fac(n)**4/396**(4*n), (n, 0, oo)), 100) == pistr
+    assert NS(1/Sum(
+        binomial(2*n, n)**3 * (42*n + 5)/2**(12*n + 4), (n, 0, oo)), 100) == pistr
+    # Machin's formula for pi
+    assert NS(16*Sum((-1)**n/(2*n + 1)/5**(2*n + 1), (n, 0, oo)) -
+        4*Sum((-1)**n/(2*n + 1)/239**(2*n + 1), (n, 0, oo)), 100) == pistr
+
+    # Apery's constant
+    astr = NS(zeta(3), 100)
+    P = 126392*n**5 + 412708*n**4 + 531578*n**3 + 336367*n**2 + 104000* \
+        n + 12463
+    assert NS(Sum((-1)**n * P / 24 * (fac(2*n + 1)*fac(2*n)*fac(
+        n))**3 / fac(3*n + 2) / fac(4*n + 3)**3, (n, 0, oo)), 100) == astr
+    assert NS(Sum((-1)**n * (205*n**2 + 250*n + 77)/64 * fac(n)**10 /
+              fac(2*n + 1)**5, (n, 0, oo)), 100) == astr
+
+
+def test_evalf_fast_series_issue_4021():
+    # Catalan's constant
+    assert NS(Sum((-1)**(n - 1)*2**(8*n)*(40*n**2 - 24*n + 3)*fac(2*n)**3*
+        fac(n)**2/n**3/(2*n - 1)/fac(4*n)**2, (n, 1, oo))/64, 100) == \
+        NS(Catalan, 100)
+    astr = NS(zeta(3), 100)
+    assert NS(5*Sum(
+        (-1)**(n - 1)*fac(n)**2 / n**3 / fac(2*n), (n, 1, oo))/2, 100) == astr
+    assert NS(Sum((-1)**(n - 1)*(56*n**2 - 32*n + 5) / (2*n - 1)**2 * fac(n - 1)
+              **3 / fac(3*n), (n, 1, oo))/4, 100) == astr
+
+
+def test_evalf_slow_series():
+    assert NS(Sum((-1)**n / n, (n, 1, oo)), 15) == NS(-log(2), 15)
+    assert NS(Sum((-1)**n / n, (n, 1, oo)), 50) == NS(-log(2), 50)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 15) == NS(pi**2/6, 15)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 100) == NS(pi**2/6, 100)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 500) == NS(pi**2/6, 500)
+    assert NS(Sum((-1)**n / (2*n + 1)**3, (n, 0, oo)), 15) == NS(pi**3/32, 15)
+    assert NS(Sum((-1)**n / (2*n + 1)**3, (n, 0, oo)), 50) == NS(pi**3/32, 50)
+
+
+def test_evalf_oo_to_oo():
+    # There used to be an error in certain cases
+    # Does not evaluate, but at least do not throw an error
+    # Evaluates symbolically to 0, which is not correct
+    assert Sum(1/(n**2+1), (n, -oo, oo)).evalf() == Sum(1/(n**2+1), (n, -oo, oo))
+    # This evaluates if from 1 to oo and symbolically
+    assert Sum(1/(factorial(abs(n))), (n, -oo, -1)).evalf() == Sum(1/(factorial(abs(n))), (n, -oo, -1))
+
+
+def test_euler_maclaurin():
+    # Exact polynomial sums with E-M
+    def check_exact(f, a, b, m, n):
+        A = Sum(f, (k, a, b))
+        s, e = A.euler_maclaurin(m, n)
+        assert (e == 0) and (s.expand() == A.doit())
+    check_exact(k**4, a, b, 0, 2)
+    check_exact(k**4 + 2*k, a, b, 1, 2)
+    check_exact(k**4 + k**2, a, b, 1, 5)
+    check_exact(k**5, 2, 6, 1, 2)
+    check_exact(k**5, 2, 6, 1, 3)
+    assert Sum(x-1, (x, 0, 2)).euler_maclaurin(m=30, n=30, eps=2**-15) == (0, 0)
+    # Not exact
+    assert Sum(k**6, (k, a, b)).euler_maclaurin(0, 2)[1] != 0
+    # Numerical test
+    for mi, ni in [(2, 4), (2, 20), (10, 20), (18, 20)]:
+        A = Sum(1/k**3, (k, 1, oo))
+        s, e = A.euler_maclaurin(mi, ni)
+        assert abs((s - zeta(3)).evalf()) < e.evalf()
+
+    raises(ValueError, lambda: Sum(1, (x, 0, 1), (k, 0, 1)).euler_maclaurin())
+
+
+@slow
+def test_evalf_euler_maclaurin():
+    assert NS(Sum(1/k**k, (k, 1, oo)), 15) == '1.29128599706266'
+    assert NS(Sum(1/k**k, (k, 1, oo)),
+              50) == '1.2912859970626635404072825905956005414986193682745'
+    assert NS(Sum(1/k - log(1 + 1/k), (k, 1, oo)), 15) == NS(EulerGamma, 15)
+    assert NS(Sum(1/k - log(1 + 1/k), (k, 1, oo)), 50) == NS(EulerGamma, 50)
+    assert NS(Sum(log(k)/k**2, (k, 1, oo)), 15) == '0.937548254315844'
+    assert NS(Sum(log(k)/k**2, (k, 1, oo)),
+              50) == '0.93754825431584375370257409456786497789786028861483'
+    assert NS(Sum(1/k, (k, 1000000, 2000000)), 15) == '0.693147930560008'
+    assert NS(Sum(1/k, (k, 1000000, 2000000)),
+              50) == '0.69314793056000780941723211364567656807940638436025'
+
+
+def test_evalf_symbolic():
+    # issue 6328
+    expr = Sum(f(x), (x, 1, 3)) + Sum(g(x), (x, 1, 3))
+    assert expr.evalf() == expr
+
+
+def test_evalf_issue_3273():
+    assert Sum(0, (k, 1, oo)).evalf() == 0
+
+
+def test_simple_products():
+    assert Product(S.NaN, (x, 1, 3)) is S.NaN
+    assert product(S.NaN, (x, 1, 3)) is S.NaN
+    assert Product(x, (n, a, a)).doit() == x
+    assert Product(x, (x, a, a)).doit() == a
+    assert Product(x, (y, 1, a)).doit() == x**a
+
+    lo, hi = 1, 2
+    s1 = Product(n, (n, lo, hi))
+    s2 = Product(n, (n, hi, lo))
+    assert s1 != s2
+    # This IS correct according to Karr product convention
+    assert s1.doit() == 2
+    assert s2.doit() == 1
+
+    lo, hi = x, x + 1
+    s1 = Product(n, (n, lo, hi))
+    s2 = Product(n, (n, hi, lo))
+    s3 = 1 / Product(n, (n, hi + 1, lo - 1))
+    assert s1 != s2
+    # This IS correct according to Karr product convention
+    assert s1.doit() == x*(x + 1)
+    assert s2.doit() == 1
+    assert s3.doit() == x*(x + 1)
+
+    assert Product(Integral(2*x, (x, 1, y)) + 2*x, (x, 1, 2)).doit() == \
+        (y**2 + 1)*(y**2 + 3)
+    assert product(2, (n, a, b)) == 2**(b - a + 1)
+    assert product(n, (n, 1, b)) == factorial(b)
+    assert product(n**3, (n, 1, b)) == factorial(b)**3
+    assert product(3**(2 + n), (n, a, b)) \
+        == 3**(2*(1 - a + b) + b/2 + (b**2)/2 + a/2 - (a**2)/2)
+    assert product(cos(n), (n, 3, 5)) == cos(3)*cos(4)*cos(5)
+    assert product(cos(n), (n, x, x + 2)) == cos(x)*cos(x + 1)*cos(x + 2)
+    assert isinstance(product(cos(n), (n, x, x + S.Half)), Product)
+    # If Product managed to evaluate this one, it most likely got it wrong!
+    assert isinstance(Product(n**n, (n, 1, b)), Product)
+
+
+def test_rational_products():
+    assert combsimp(product(1 + 1/n, (n, a, b))) == (1 + b)/a
+    assert combsimp(product(n + 1, (n, a, b))) == gamma(2 + b)/gamma(1 + a)
+    assert combsimp(product((n + 1)/(n - 1), (n, a, b))) == b*(1 + b)/(a*(a - 1))
+    assert combsimp(product(n/(n + 1)/(n + 2), (n, a, b))) == \
+        a*gamma(a + 2)/(b + 1)/gamma(b + 3)
+    assert combsimp(product(n*(n + 1)/(n - 1)/(n - 2), (n, a, b))) == \
+        b**2*(b - 1)*(1 + b)/(a - 1)**2/(a*(a - 2))
+
+
+def test_wallis_product():
+    # Wallis product, given in two different forms to ensure that Product
+    # can factor simple rational expressions
+    A = Product(4*n**2 / (4*n**2 - 1), (n, 1, b))
+    B = Product((2*n)*(2*n)/(2*n - 1)/(2*n + 1), (n, 1, b))
+    R = pi*gamma(b + 1)**2/(2*gamma(b + S.Half)*gamma(b + Rational(3, 2)))
+    assert simplify(A.doit()) == R
+    assert simplify(B.doit()) == R
+    # This one should eventually also be doable (Euler's product formula for sin)
+    # assert Product(1+x/n**2, (n, 1, b)) == ...
+
+
+def test_telescopic_sums():
+    #checks also input 2 of comment 1 issue 4127
+    assert Sum(1/k - 1/(k + 1), (k, 1, n)).doit() == 1 - 1/(1 + n)
+    assert Sum(
+        f(k) - f(k + 2), (k, m, n)).doit() == -f(1 + n) - f(2 + n) + f(m) + f(1 + m)
+    assert Sum(cos(k) - cos(k + 3), (k, 1, n)).doit() == -cos(1 + n) - \
+        cos(2 + n) - cos(3 + n) + cos(1) + cos(2) + cos(3)
+
+    # dummy variable shouldn't matter
+    assert telescopic(1/m, -m/(1 + m), (m, n - 1, n)) == \
+        telescopic(1/k, -k/(1 + k), (k, n - 1, n))
+
+    assert Sum(1/x/(x - 1), (x, a, b)).doit() == 1/(a - 1) - 1/b
+    eq = 1/((5*n + 2)*(5*(n + 1) + 2))
+    assert Sum(eq, (n, 0, oo)).doit() == S(1)/10
+    nz = symbols('nz', nonzero=True)
+    v = Sum(eq.subs(5, nz), (n, 0, oo)).doit()
+    assert v.subs(nz, 5).simplify() == S(1)/10
+    # check that apart is being used in non-symbolic case
+    s = Sum(eq, (n, 0, k)).doit()
+    v = Sum(eq, (n, 0, 10**100)).doit()
+    assert v == s.subs(k, 10**100)
+
+
+def test_sum_reconstruct():
+    s = Sum(n**2, (n, -1, 1))
+    assert s == Sum(*s.args)
+    raises(ValueError, lambda: Sum(x, x))
+    raises(ValueError, lambda: Sum(x, (x, 1)))
+
+
+def test_limit_subs():
+    for F in (Sum, Product, Integral):
+        assert F(a*exp(a), (a, -2, 2)) == F(a*exp(a), (a, -b, b)).subs(b, 2)
+        assert F(a, (a, F(b, (b, 1, 2)), 4)).subs(F(b, (b, 1, 2)), c) == \
+            F(a, (a, c, 4))
+        assert F(x, (x, 1, x + y)).subs(x, 1) == F(x, (x, 1, y + 1))
+
+
+def test_function_subs():
+    S = Sum(x*f(y),(x,0,oo),(y,0,oo))
+    assert S.subs(f(y),y) == Sum(x*y,(x,0,oo),(y,0,oo))
+    assert S.subs(f(x),x) == S
+    raises(ValueError, lambda: S.subs(f(y),x+y) )
+    S = Sum(x*log(y),(x,0,oo),(y,0,oo))
+    assert S.subs(log(y),y) == S
+    S = Sum(x*f(y),(x,0,oo),(y,0,oo))
+    assert S.subs(f(y),y) == Sum(x*y,(x,0,oo),(y,0,oo))
+
+
+def test_equality():
+    # if this fails remove special handling below
+    raises(ValueError, lambda: Sum(x, x))
+    r = symbols('x', real=True)
+    for F in (Sum, Product, Integral):
+        try:
+            assert F(x, x) != F(y, y)
+            assert F(x, (x, 1, 2)) != F(x, x)
+            assert F(x, (x, x)) != F(x, x)  # or else they print the same
+            assert F(1, x) != F(1, y)
+        except ValueError:
+            pass
+        assert F(a, (x, 1, 2)) != F(a, (x, 1, 3))  # diff limit
+        assert F(a, (x, 1, x)) != F(a, (y, 1, y))
+        assert F(a, (x, 1, 2)) != F(b, (x, 1, 2))  # diff expression
+        assert F(x, (x, 1, 2)) != F(r, (r, 1, 2))  # diff assumptions
+        assert F(1, (x, 1, x)) != F(1, (y, 1, x))  # only dummy is diff
+        assert F(1, (x, 1, x)).dummy_eq(F(1, (y, 1, x)))
+
+    # issue 5265
+    assert Sum(x, (x, 1, x)).subs(x, a) == Sum(x, (x, 1, a))
+
+
+def test_Sum_doit():
+    assert Sum(n*Integral(a**2), (n, 0, 2)).doit() == a**3
+    assert Sum(n*Integral(a**2), (n, 0, 2)).doit(deep=False) == \
+        3*Integral(a**2)
+    assert summation(n*Integral(a**2), (n, 0, 2)) == 3*Integral(a**2)
+
+    # test nested sum evaluation
+    s = Sum( Sum( Sum(2,(z,1,n+1)), (y,x+1,n)), (x,1,n))
+    assert 0 == (s.doit() - n*(n+1)*(n-1)).factor()
+
+    # Integer assumes finite
+    assert Sum(KroneckerDelta(x, y), (x, -oo, oo)).doit() == Piecewise((1, And(-oo < y, y < oo)), (0, True))
+    assert Sum(KroneckerDelta(m, n), (m, -oo, oo)).doit() == 1
+    assert Sum(m*KroneckerDelta(x, y), (x, -oo, oo)).doit() == Piecewise((m, And(-oo < y, y < oo)), (0, True))
+    assert Sum(x*KroneckerDelta(m, n), (m, -oo, oo)).doit() == x
+    assert Sum(Sum(KroneckerDelta(m, n), (m, 1, 3)), (n, 1, 3)).doit() == 3
+    assert Sum(Sum(KroneckerDelta(k, m), (m, 1, 3)), (n, 1, 3)).doit() == \
+           3 * Piecewise((1, And(1 <= k, k <= 3)), (0, True))
+    assert Sum(f(n) * Sum(KroneckerDelta(m, n), (m, 0, oo)), (n, 1, 3)).doit() == \
+           f(1) + f(2) + f(3)
+    assert Sum(f(n) * Sum(KroneckerDelta(m, n), (m, 0, oo)), (n, 1, oo)).doit() == \
+           Sum(f(n), (n, 1, oo))
+
+    # issue 2597
+    nmax = symbols('N', integer=True, positive=True)
+    pw = Piecewise((1, And(1 <= n, n <= nmax)), (0, True))
+    assert Sum(pw, (n, 1, nmax)).doit() == Sum(Piecewise((1, nmax >= n),
+                    (0, True)), (n, 1, nmax))
+
+    q, s = symbols('q, s')
+    assert summation(1/n**(2*s), (n, 1, oo)) == Piecewise((zeta(2*s), 2*s > 1),
+        (Sum(n**(-2*s), (n, 1, oo)), True))
+    assert summation(1/(n+1)**s, (n, 0, oo)) == Piecewise((zeta(s), s > 1),
+        (Sum((n + 1)**(-s), (n, 0, oo)), True))
+    assert summation(1/(n+q)**s, (n, 0, oo)) == Piecewise(
+        (zeta(s, q), And(q > 0, s > 1)),
+        (Sum((n + q)**(-s), (n, 0, oo)), True))
+    assert summation(1/(n+q)**s, (n, q, oo)) == Piecewise(
+        (zeta(s, 2*q), And(2*q > 0, s > 1)),
+        (Sum((n + q)**(-s), (n, q, oo)), True))
+    assert summation(1/n**2, (n, 1, oo)) == zeta(2)
+    assert summation(1/n**s, (n, 0, oo)) == Sum(n**(-s), (n, 0, oo))
+
+
+def test_Product_doit():
+    assert Product(n*Integral(a**2), (n, 1, 3)).doit() == 2 * a**9 / 9
+    assert Product(n*Integral(a**2), (n, 1, 3)).doit(deep=False) == \
+        6*Integral(a**2)**3
+    assert product(n*Integral(a**2), (n, 1, 3)) == 6*Integral(a**2)**3
+
+
+def test_Sum_interface():
+    assert isinstance(Sum(0, (n, 0, 2)), Sum)
+    assert Sum(nan, (n, 0, 2)) is nan
+    assert Sum(nan, (n, 0, oo)) is nan
+    assert Sum(0, (n, 0, 2)).doit() == 0
+    assert isinstance(Sum(0, (n, 0, oo)), Sum)
+    assert Sum(0, (n, 0, oo)).doit() == 0
+    raises(ValueError, lambda: Sum(1))
+    raises(ValueError, lambda: summation(1))
+
+
+def test_diff():
+    assert Sum(x, (x, 1, 2)).diff(x) == 0
+    assert Sum(x*y, (x, 1, 2)).diff(x) == 0
+    assert Sum(x*y, (y, 1, 2)).diff(x) == Sum(y, (y, 1, 2))
+    e = Sum(x*y, (x, 1, a))
+    assert e.diff(a) == Derivative(e, a)
+    assert Sum(x*y, (x, 1, 3), (a, 2, 5)).diff(y).doit() == \
+        Sum(x*y, (x, 1, 3), (a, 2, 5)).doit().diff(y) == 24
+    assert Sum(x, (x, 1, 2)).diff(y) == 0
+
+
+def test_hypersum():
+    assert simplify(summation(x**n/fac(n), (n, 1, oo))) == -1 + exp(x)
+    assert summation((-1)**n * x**(2*n) / fac(2*n), (n, 0, oo)) == cos(x)
+    assert simplify(summation((-1)**n*x**(2*n + 1) /
+        factorial(2*n + 1), (n, 3, oo))) == -x + sin(x) + x**3/6 - x**5/120
+
+    assert summation(1/(n + 2)**3, (n, 1, oo)) == Rational(-9, 8) + zeta(3)
+    assert summation(1/n**4, (n, 1, oo)) == pi**4/90
+
+    s = summation(x**n*n, (n, -oo, 0))
+    assert s.is_Piecewise
+    assert s.args[0].args[0] == -1/(x*(1 - 1/x)**2)
+    assert s.args[0].args[1] == (abs(1/x) < 1)
+
+    m = Symbol('n', integer=True, positive=True)
+    assert summation(binomial(m, k), (k, 0, m)) == 2**m
+
+
+def test_issue_4170():
+    assert summation(1/factorial(k), (k, 0, oo)) == E
+
+
+def test_is_commutative():
+    from sympy.physics.secondquant import NO, F, Fd
+    m = Symbol('m', commutative=False)
+    for f in (Sum, Product, Integral):
+        assert f(z, (z, 1, 1)).is_commutative is True
+        assert f(z*y, (z, 1, 6)).is_commutative is True
+        assert f(m*x, (x, 1, 2)).is_commutative is False
+
+        assert f(NO(Fd(x)*F(y))*z, (z, 1, 2)).is_commutative is False
+
+
+def test_is_zero():
+    for func in [Sum, Product]:
+        assert func(0, (x, 1, 1)).is_zero is True
+        assert func(x, (x, 1, 1)).is_zero is None
+
+    assert Sum(0, (x, 1, 0)).is_zero is True
+    assert Product(0, (x, 1, 0)).is_zero is False
+
+
+def test_is_number():
+    # is number should not rely on evaluation or assumptions,
+    # it should be equivalent to `not foo.free_symbols`
+    assert Sum(1, (x, 1, 1)).is_number is True
+    assert Sum(1, (x, 1, x)).is_number is False
+    assert Sum(0, (x, y, z)).is_number is False
+    assert Sum(x, (y, 1, 2)).is_number is False
+    assert Sum(x, (y, 1, 1)).is_number is False
+    assert Sum(x, (x, 1, 2)).is_number is True
+    assert Sum(x*y, (x, 1, 2), (y, 1, 3)).is_number is True
+
+    assert Product(2, (x, 1, 1)).is_number is True
+    assert Product(2, (x, 1, y)).is_number is False
+    assert Product(0, (x, y, z)).is_number is False
+    assert Product(1, (x, y, z)).is_number is False
+    assert Product(x, (y, 1, x)).is_number is False
+    assert Product(x, (y, 1, 2)).is_number is False
+    assert Product(x, (y, 1, 1)).is_number is False
+    assert Product(x, (x, 1, 2)).is_number is True
+
+
+def test_free_symbols():
+    for func in [Sum, Product]:
+        assert func(1, (x, 1, 2)).free_symbols == set()
+        assert func(0, (x, 1, y)).free_symbols == {y}
+        assert func(2, (x, 1, y)).free_symbols == {y}
+        assert func(x, (x, 1, 2)).free_symbols == set()
+        assert func(x, (x, 1, y)).free_symbols == {y}
+        assert func(x, (y, 1, y)).free_symbols == {x, y}
+        assert func(x, (y, 1, 2)).free_symbols == {x}
+        assert func(x, (y, 1, 1)).free_symbols == {x}
+        assert func(x, (y, 1, z)).free_symbols == {x, z}
+        assert func(x, (x, 1, y), (y, 1, 2)).free_symbols == set()
+        assert func(x, (x, 1, y), (y, 1, z)).free_symbols == {z}
+        assert func(x, (x, 1, y), (y, 1, y)).free_symbols == {y}
+        assert func(x, (y, 1, y), (y, 1, z)).free_symbols == {x, z}
+    assert Sum(1, (x, 1, y)).free_symbols == {y}
+    # free_symbols answers whether the object *as written* has free symbols,
+    # not whether the evaluated expression has free symbols
+    assert Product(1, (x, 1, y)).free_symbols == {y}
+    # don't count free symbols that are not independent of integration
+    # variable(s)
+    assert func(f(x), (f(x), 1, 2)).free_symbols == set()
+    assert func(f(x), (f(x), 1, x)).free_symbols == {x}
+    assert func(f(x), (f(x), 1, y)).free_symbols == {y}
+    assert func(f(x), (z, 1, y)).free_symbols == {x, y}
+
+
+def test_conjugate_transpose():
+    A, B = symbols("A B", commutative=False)
+    p = Sum(A*B**n, (n, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    p = Sum(B**n*A, (n, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+
+def test_noncommutativity_honoured():
+    A, B = symbols("A B", commutative=False)
+    M = symbols('M', integer=True, positive=True)
+    p = Sum(A*B**n, (n, 1, M))
+    assert p.doit() == A*Piecewise((M, Eq(B, 1)),
+                                   ((B - B**(M + 1))*(1 - B)**(-1), True))
+
+    p = Sum(B**n*A, (n, 1, M))
+    assert p.doit() == Piecewise((M, Eq(B, 1)),
+                                 ((B - B**(M + 1))*(1 - B)**(-1), True))*A
+
+    p = Sum(B**n*A*B**n, (n, 1, M))
+    assert p.doit() == p
+
+
+def test_issue_4171():
+    assert summation(factorial(2*k + 1)/factorial(2*k), (k, 0, oo)) is oo
+    assert summation(2*k + 1, (k, 0, oo)) is oo
+
+
+def test_issue_6273():
+    assert Sum(x, (x, 1, n)).n(2, subs={n: 1}) == Float(1, 2)
+
+
+def test_issue_6274():
+    assert Sum(x, (x, 1, 0)).doit() == 0
+    assert NS(Sum(x, (x, 1, 0))) == '0'
+    assert Sum(n, (n, 10, 5)).doit() == -30
+    assert NS(Sum(n, (n, 10, 5))) == '-30.0000000000000'
+
+
+def test_simplify_sum():
+    y, t, v = symbols('y, t, v')
+
+    _simplify = lambda e: simplify(e, doit=False)
+    assert _simplify(Sum(x*y, (x, n, m), (y, a, k)) + \
+        Sum(y, (x, n, m), (y, a, k))) == Sum(y * (x + 1), (x, n, m), (y, a, k))
+    assert _simplify(Sum(x, (x, n, m)) + Sum(x, (x, m + 1, a))) == \
+        Sum(x, (x, n, a))
+    assert _simplify(Sum(x, (x, k + 1, a)) + Sum(x, (x, n, k))) == \
+        Sum(x, (x, n, a))
+    assert _simplify(Sum(x, (x, k + 1, a)) + Sum(x + 1, (x, n, k))) == \
+        Sum(x, (x, n, a)) + Sum(1, (x, n, k))
+    assert _simplify(Sum(x, (x, 0, 3)) * 3 + 3 * Sum(x, (x, 4, 6)) + \
+        4 * Sum(z, (z, 0, 1))) == 4*Sum(z, (z, 0, 1)) + 3*Sum(x, (x, 0, 6))
+    assert _simplify(3*Sum(x**2, (x, a, b)) + Sum(x, (x, a, b))) == \
+        Sum(x*(3*x + 1), (x, a, b))
+    assert _simplify(Sum(x**3, (x, n, k)) * 3 + 3 * Sum(x, (x, n, k)) + \
+        4 * y * Sum(z, (z, n, k))) + 1 == \
+            4*y*Sum(z, (z, n, k)) + 3*Sum(x**3 + x, (x, n, k)) + 1
+    assert _simplify(Sum(x, (x, a, b)) + 1 + Sum(x, (x, b + 1, c))) == \
+        1 + Sum(x, (x, a, c))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + \
+        Sum(x, (t, b+1, c))) == x * Sum(1, (t, a, c)) + y * Sum(1, (t, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(x, (t, b+1, c)) + \
+        Sum(y, (t, a, b))) == x * Sum(1, (t, a, c)) + y * Sum(1, (t, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + 2 * Sum(x, (t, b+1, c))) == \
+        _simplify(Sum(x, (t, a, b)) + Sum(x, (t, b+1, c)) + Sum(x, (t, b+1, c)))
+    assert _simplify(Sum(x, (x, a, b))*Sum(x**2, (x, a, b))) == \
+        Sum(x, (x, a, b)) * Sum(x**2, (x, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + Sum(z, (t, a, b))) \
+        == (x + y + z) * Sum(1, (t, a, b))          # issue 8596
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + Sum(z, (t, a, b)) + \
+        Sum(v, (t, a, b))) == (x + y + z + v) * Sum(1, (t, a, b))  # issue 8596
+    assert _simplify(Sum(x * y, (x, a, b)) / (3 * y)) == \
+        (Sum(x, (x, a, b)) / 3)
+    assert _simplify(Sum(f(x) * y * z, (x, a, b)) / (y * z)) \
+        == Sum(f(x), (x, a, b))
+    assert _simplify(Sum(c * x, (x, a, b)) - c * Sum(x, (x, a, b))) == 0
+    assert _simplify(c * (Sum(x, (x, a, b))  + y)) == c * (y + Sum(x, (x, a, b)))
+    assert _simplify(c * (Sum(x, (x, a, b)) + y * Sum(x, (x, a, b)))) == \
+        c * (y + 1) * Sum(x, (x, a, b))
+    assert _simplify(Sum(Sum(c * x, (x, a, b)), (y, a, b))) == \
+                c * Sum(x, (x, a, b), (y, a, b))
+    assert _simplify(Sum((3 + y) * Sum(c * x, (x, a, b)), (y, a, b))) == \
+                c * Sum((3 + y), (y, a, b)) * Sum(x, (x, a, b))
+    assert _simplify(Sum((3 + t) * Sum(c * t, (x, a, b)), (y, a, b))) == \
+                c*t*(t + 3)*Sum(1, (x, a, b))*Sum(1, (y, a, b))
+    assert _simplify(Sum(Sum(d * t, (x, a, b - 1)) + \
+                Sum(d * t, (x, b, c)), (t, a, b))) == \
+                    d * Sum(1, (x, a, c)) * Sum(t, (t, a, b))
+    assert _simplify(Sum(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
+        2 * Sum(1, (t, a, b))
+
+
+def test_change_index():
+    b, v, w = symbols('b, v, w', integer = True)
+
+    assert Sum(x, (x, a, b)).change_index(x, x + 1, y) == \
+        Sum(y - 1, (y, a + 1, b + 1))
+    assert Sum(x**2, (x, a, b)).change_index( x, x - 1) == \
+        Sum((x+1)**2, (x, a - 1, b - 1))
+    assert Sum(x**2, (x, a, b)).change_index( x, -x, y) == \
+        Sum((-y)**2, (y, -b, -a))
+    assert Sum(x, (x, a, b)).change_index( x, -x - 1) == \
+        Sum(-x - 1, (x, -b - 1, -a - 1))
+    assert Sum(x*y, (x, a, b), (y, c, d)).change_index( x, x - 1, z) == \
+        Sum((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
+    assert Sum(x, (x, a, b)).change_index( x, x + v) == \
+        Sum(-v + x, (x, a + v, b + v))
+    assert Sum(x, (x, a, b)).change_index( x, -x - v) == \
+        Sum(-v - x, (x, -b - v, -a - v))
+    assert Sum(x, (x, a, b)).change_index(x, w*x, v) == \
+        Sum(v/w, (v, b*w, a*w))
+    raises(ValueError, lambda: Sum(x, (x, a, b)).change_index(x, 2*x))
+
+
+def test_reorder():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+    assert Sum(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
+        Sum(x, (x, c, d), (x, a, b))
+    assert Sum(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
+        (2, 0), (0, 1)) == Sum(x*y + z, (z, m, n), (y, c, d), (x, a, b))
+    assert Sum(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (0, 1), (1, 2), (0, 2)) == Sum(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Sum(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (x, y), (y, z), (x, z)) == Sum(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+
+
+def test_reverse_order():
+    assert Sum(x, (x, 0, 3)).reverse_order(0) == Sum(-x, (x, 4, -1))
+    assert Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
+           Sum(x*y, (x, 6, 0), (y, 7, -1))
+    assert Sum(x, (x, 1, 2)).reverse_order(0) == Sum(-x, (x, 3, 0))
+    assert Sum(x, (x, 1, 3)).reverse_order(0) == Sum(-x, (x, 4, 0))
+    assert Sum(x, (x, 1, a)).reverse_order(0) == Sum(-x, (x, a + 1, 0))
+    assert Sum(x, (x, a, 5)).reverse_order(0) == Sum(-x, (x, 6, a - 1))
+    assert Sum(x, (x, a + 1, a + 5)).reverse_order(0) == \
+                         Sum(-x, (x, a + 6, a))
+    assert Sum(x, (x, a + 1, a + 2)).reverse_order(0) == \
+           Sum(-x, (x, a + 3, a))
+    assert Sum(x, (x, a + 1, a + 1)).reverse_order(0) == \
+           Sum(-x, (x, a + 2, a))
+    assert Sum(x, (x, a, b)).reverse_order(0) == Sum(-x, (x, b + 1, a - 1))
+    assert Sum(x, (x, a, b)).reverse_order(x) == Sum(-x, (x, b + 1, a - 1))
+    assert Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+    assert Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+
+def test_issue_7097():
+    assert sum(x**n/n for n in range(1, 401)) == summation(x**n/n, (n, 1, 400))
+
+
+def test_factor_expand_subs():
+    # test factoring
+    assert Sum(4 * x, (x, 1, y)).factor() == 4 * Sum(x, (x, 1, y))
+    assert Sum(x * a, (x, 1, y)).factor() == a * Sum(x, (x, 1, y))
+    assert Sum(4 * x * a, (x, 1, y)).factor() == 4 * a * Sum(x, (x, 1, y))
+    assert Sum(4 * x * y, (x, 1, y)).factor() == 4 * y * Sum(x, (x, 1, y))
+
+    # test expand
+    _x = Symbol('x', zero=False)
+    assert Sum(x+1,(x,1,y)).expand() == Sum(x,(x,1,y)) + Sum(1,(x,1,y))
+    assert Sum(x+a*x**2,(x,1,y)).expand() == Sum(x,(x,1,y)) + Sum(a*x**2,(x,1,y))
+    assert Sum(_x**(n + 1)*(n + 1), (n, -1, oo)).expand() \
+        == Sum(n*_x*_x**n + _x*_x**n, (n, -1, oo))
+    assert Sum(x**(n + 1)*(n + 1), (n, -1, oo)).expand(power_exp=False) \
+        == Sum(n*x**(n + 1) + x**(n + 1), (n, -1, oo))
+    assert Sum(x**(n + 1)*(n + 1), (n, -1, oo)).expand(force=True) \
+           == Sum(x*x**n, (n, -1, oo)) + Sum(n*x*x**n, (n, -1, oo))
+    assert Sum(a*n+a*n**2,(n,0,4)).expand() \
+        == Sum(a*n,(n,0,4)) + Sum(a*n**2,(n,0,4))
+    assert Sum(_x**a*_x**n,(x,0,3)) \
+        == Sum(_x**(a+n),(x,0,3)).expand(power_exp=True)
+    _a, _n = symbols('a n', positive=True)
+    assert Sum(x**(_a+_n),(x,0,3)).expand(power_exp=True) \
+        == Sum(x**_a*x**_n, (x, 0, 3))
+    assert Sum(x**(_a-_n),(x,0,3)).expand(power_exp=True) \
+        == Sum(x**(_a-_n),(x,0,3)).expand(power_exp=False)
+
+    # test subs
+    assert Sum(1/(1+a*x**2),(x,0,3)).subs([(a,3)]) == Sum(1/(1+3*x**2),(x,0,3))
+    assert Sum(x*y,(x,0,y),(y,0,x)).subs([(x,3)]) == Sum(x*y,(x,0,y),(y,0,3))
+    assert Sum(x,(x,1,10)).subs([(x,y-2)]) == Sum(x,(x,1,10))
+    assert Sum(1/x,(x,1,10)).subs([(x,(3+n)**3)]) == Sum(1/x,(x,1,10))
+    assert Sum(1/x,(x,1,10)).subs([(x,3*x-2)]) == Sum(1/x,(x,1,10))
+
+
+def test_distribution_over_equality():
+    assert Product(Eq(x*2, f(x)), (x, 1, 3)).doit() == Eq(48, f(1)*f(2)*f(3))
+    assert Sum(Eq(f(x), x**2), (x, 0, y)) == \
+        Eq(Sum(f(x), (x, 0, y)), Sum(x**2, (x, 0, y)))
+
+
+def test_issue_2787():
+    n, k = symbols('n k', positive=True, integer=True)
+    p = symbols('p', positive=True)
+    binomial_dist = binomial(n, k)*p**k*(1 - p)**(n - k)
+    s = Sum(binomial_dist*k, (k, 0, n))
+    res = s.doit().simplify()
+    ans = Piecewise(
+        (n*p, x),
+        (Sum(k*p**k*binomial(n, k)*(1 - p)**(n - k), (k, 0, n)),
+        True)).subs(x, (Eq(n, 1) | (n > 1)) & (p/Abs(p - 1) <= 1))
+    ans2 = Piecewise(
+        (n*p, x),
+        (factorial(n)*Sum(p**k*(1 - p)**(-k + n)/
+        (factorial(-k + n)*factorial(k - 1)), (k, 0, n)),
+        True)).subs(x, (Eq(n, 1) | (n > 1)) & (p/Abs(p - 1) <= 1))
+    assert res in [ans, ans2]  # XXX system dependent
+    # Issue #17165: make sure that another simplify does not complicate
+    # the result by much. Why didn't first simplify replace
+    # Eq(n, 1) | (n > 1) with True?
+    assert res.simplify().count_ops() <= res.count_ops() + 2
+
+
+def test_issue_4668():
+    assert summation(1/n, (n, 2, oo)) is oo
+
+
+def test_matrix_sum():
+    A = Matrix([[0, 1], [n, 0]])
+
+    result = Sum(A, (n, 0, 3)).doit()
+    assert result == Matrix([[0, 4], [6, 0]])
+    assert result.__class__ == ImmutableDenseMatrix
+
+    A = SparseMatrix([[0, 1], [n, 0]])
+
+    result = Sum(A, (n, 0, 3)).doit()
+    assert result.__class__ == ImmutableSparseMatrix
+
+
+def test_failing_matrix_sum():
+    n = Symbol('n')
+    # TODO Implement matrix geometric series summation.
+    A = Matrix([[0, 1, 0], [-1, 0, 0], [0, 0, 0]])
+    assert Sum(A ** n, (n, 1, 4)).doit() == \
+        Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+    # issue sympy/sympy#16989
+    assert summation(A**n, (n, 1, 1)) == A
+
+
+def test_indexed_idx_sum():
+    i = symbols('i', cls=Idx)
+    r = Indexed('r', i)
+    assert Sum(r, (i, 0, 3)).doit() == sum(r.xreplace({i: j}) for j in range(4))
+    assert Product(r, (i, 0, 3)).doit() == prod([r.xreplace({i: j}) for j in range(4)])
+
+    j = symbols('j', integer=True)
+    assert Sum(r, (i, j, j+2)).doit() == sum(r.xreplace({i: j+k}) for k in range(3))
+    assert Product(r, (i, j, j+2)).doit() == prod([r.xreplace({i: j+k}) for k in range(3)])
+
+    k = Idx('k', range=(1, 3))
+    A = IndexedBase('A')
+    assert Sum(A[k], k).doit() == sum(A[Idx(j, (1, 3))] for j in range(1, 4))
+    assert Product(A[k], k).doit() == prod([A[Idx(j, (1, 3))] for j in range(1, 4)])
+
+    raises(ValueError, lambda: Sum(A[k], (k, 1, 4)))
+    raises(ValueError, lambda: Sum(A[k], (k, 0, 3)))
+    raises(ValueError, lambda: Sum(A[k], (k, 2, oo)))
+
+    raises(ValueError, lambda: Product(A[k], (k, 1, 4)))
+    raises(ValueError, lambda: Product(A[k], (k, 0, 3)))
+    raises(ValueError, lambda: Product(A[k], (k, 2, oo)))
+
+
+@slow
+def test_is_convergent():
+    # divergence tests --
+    assert Sum(n/(2*n + 1), (n, 1, oo)).is_convergent() is S.false
+    assert Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(3**(-2*n - 1)*n**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum((-1)**n*n, (n, 3, oo)).is_convergent() is S.false
+    assert Sum((-1)**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(log(1/n), (n, 2, oo)).is_convergent() is S.false
+
+    # Raabe's test --
+    assert Sum(Product((3*m),(m,1,n))/Product((3*m+4),(m,1,n)),(n,1,oo)).is_convergent() is S.true
+
+    # root test --
+    assert Sum((-12)**n/n, (n, 1, oo)).is_convergent() is S.false
+
+    # integral test --
+
+    # p-series test --
+    assert Sum(1/(n**2 + 1), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(1/n**Rational(6, 5), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(2/(n*sqrt(n - 1)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(sqrt(n)*sqrt(n)), (n, 2, oo)).is_convergent() is S.false
+    assert Sum(factorial(n) / factorial(n+2), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(rf(5,n)/rf(7,n),(n,1,oo)).is_convergent() is S.true
+    assert Sum((rf(1, n)*rf(2, n))/(rf(3, n)*factorial(n)),(n,1,oo)).is_convergent() is S.false
+
+    # comparison test --
+    assert Sum(1/(n + log(n)), (n, 1, oo)).is_convergent() is S.false
+    assert Sum(1/(n**2*log(n)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*log(n)), (n, 2, oo)).is_convergent() is S.false
+    assert Sum(2/(n*log(n)*log(log(n))**2), (n, 5, oo)).is_convergent() is S.true
+    assert Sum(2/(n*log(n)**2), (n, 2, oo)).is_convergent() is S.true
+    assert Sum((n - 1)/(n**2*log(n)**3), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*log(n)*log(log(n))), (n, 5, oo)).is_convergent() is S.false
+    assert Sum((n - 1)/(n*log(n)**3), (n, 3, oo)).is_convergent() is S.false
+    assert Sum(2/(n**2*log(n)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*sqrt(log(n))*log(log(n))), (n, 100, oo)).is_convergent() is S.false
+    assert Sum(log(log(n))/(n*log(n)**2), (n, 100, oo)).is_convergent() is S.true
+    assert Sum(log(n)/n**2, (n, 5, oo)).is_convergent() is S.true
+
+    # alternating series tests --
+    assert Sum((-1)**(n - 1)/(n**2 - 1), (n, 3, oo)).is_convergent() is S.true
+
+    # with -negativeInfinite Limits
+    assert Sum(1/(n**2 + 1), (n, -oo, 1)).is_convergent() is S.true
+    assert Sum(1/(n - 1), (n, -oo, -1)).is_convergent() is S.false
+    assert Sum(1/(n**2 - 1), (n, -oo, -5)).is_convergent() is S.true
+    assert Sum(1/(n**2 - 1), (n, -oo, 2)).is_convergent() is S.true
+    assert Sum(1/(n**2 - 1), (n, -oo, oo)).is_convergent() is S.true
+
+    # piecewise functions
+    f = Piecewise((n**(-2), n <= 1), (n**2, n > 1))
+    assert Sum(f, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(f, (n, -oo, oo)).is_convergent() is S.false
+    assert Sum(f, (n, 1, 100)).is_convergent() is S.true
+    #assert Sum(f, (n, -oo, 1)).is_convergent() is S.true
+
+    # integral test
+
+    assert Sum(log(n)/n**3, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(-log(n)/n**3, (n, 1, oo)).is_convergent() is S.true
+    # the following function has maxima located at (x, y) =
+    # (1.2, 0.43), (3.0, -0.25) and (6.8, 0.050)
+    eq = (x - 2)*(x**2 - 6*x + 4)*exp(-x)
+    assert Sum(eq, (x, 1, oo)).is_convergent() is S.true
+    assert Sum(eq, (x, 1, 2)).is_convergent() is S.true
+    assert Sum(1/(x**3), (x, 1, oo)).is_convergent() is S.true
+    assert Sum(1/(x**S.Half), (x, 1, oo)).is_convergent() is S.false
+
+    # issue 19545
+    assert Sum(1/n - 3/(3*n +2), (n, 1, oo)).is_convergent() is S.true
+
+    # issue 19836
+    assert Sum(4/(n + 2) - 5/(n + 1) + 1/n,(n, 7, oo)).is_convergent() is S.true
+
+
+def test_is_absolutely_convergent():
+    assert Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent() is S.false
+    assert Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent() is S.true
+
+
+@XFAIL
+def test_convergent_failing():
+    # dirichlet tests
+    assert Sum(sin(n)/n, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(sin(2*n)/n, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_6966():
+    i, k, m = symbols('i k m', integer=True)
+    z_i, q_i = symbols('z_i q_i')
+    a_k = Sum(-q_i*z_i/k,(i,1,m))
+    b_k = a_k.diff(z_i)
+    assert isinstance(b_k, Sum)
+    assert b_k == Sum(-q_i/k,(i,1,m))
+
+
+def test_issue_10156():
+    cx = Sum(2*y**2*x, (x, 1,3))
+    e = 2*y*Sum(2*cx*x**2, (x, 1, 9))
+    assert e.factor() == \
+        8*y**3*Sum(x, (x, 1, 3))*Sum(x**2, (x, 1, 9))
+
+
+def test_issue_10973():
+    assert Sum((-n + (n**3 + 1)**(S(1)/3))/log(n), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14129():
+    x = Symbol('x', zero=False)
+    assert Sum( k*x**k, (k, 0, n-1)).doit() == \
+        Piecewise((n**2/2 - n/2, Eq(x, 1)), ((n*x*x**n -
+            n*x**n - x*x**n + x)/(x - 1)**2, True))
+    assert Sum( x**k, (k, 0, n-1)).doit() == \
+        Piecewise((n, Eq(x, 1)), ((-x**n + 1)/(-x + 1), True))
+    assert Sum( k*(x/y+x)**k, (k, 0, n-1)).doit() == \
+        Piecewise((n*(n - 1)/2, Eq(x, y/(y + 1))),
+        (x*(y + 1)*(n*x*y*(x + x/y)**(n - 1) +
+        n*x*(x + x/y)**(n - 1) - n*y*(x + x/y)**(n - 1) -
+        x*y*(x + x/y)**(n - 1) - x*(x + x/y)**(n - 1) + y)/
+        (x*y + x - y)**2, True))
+
+
+def test_issue_14112():
+    assert Sum((-1)**n/sqrt(n), (n, 1, oo)).is_absolutely_convergent() is S.false
+    assert Sum((-1)**(2*n)/n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum((-2)**n + (-3)**n, (n, 1, oo)).is_convergent() is S.false
+
+
+def test_issue_14219():
+    A = diag(0, 2, -3)
+    res = diag(1, 15, -20)
+    assert Sum(A**n, (n, 0, 3)).doit() == res
+
+
+def test_sin_times_absolutely_convergent():
+    assert Sum(sin(n) / n**3, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(sin(n) * log(n) / n**3, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14111():
+    assert Sum(1/log(log(n)), (n, 22, oo)).is_convergent() is S.false
+
+
+def test_issue_14484():
+    assert Sum(sin(n)/log(log(n)), (n, 22, oo)).is_convergent() is S.false
+
+
+def test_issue_14640():
+    i, n = symbols("i n", integer=True)
+    a, b, c = symbols("a b c", zero=False)
+
+    assert Sum(a**-i/(a - b), (i, 0, n)).doit() == Sum(
+        1/(a*a**i - a**i*b), (i, 0, n)).doit() == Piecewise(
+            (n + 1, Eq(1/a, 1)),
+            ((-a**(-n - 1) + 1)/(1 - 1/a), True))/(a - b)
+
+    assert Sum((b*a**i - c*a**i)**-2, (i, 0, n)).doit() == Piecewise(
+        (n + 1, Eq(a**(-2), 1)),
+        ((-a**(-2*n - 2) + 1)/(1 - 1/a**2), True))/(b - c)**2
+
+    s = Sum(i*(a**(n - i) - b**(n - i))/(a - b), (i, 0, n)).doit()
+    assert not s.has(Sum)
+    assert s.subs({a: 2, b: 3, n: 5}) == 122
+
+
+def test_issue_15943():
+    s = Sum(binomial(n, k)*factorial(n - k), (k, 0, n)).doit().rewrite(gamma)
+    assert s == -E*(n + 1)*gamma(n + 1)*lowergamma(n + 1, 1)/gamma(n + 2
+        ) + E*gamma(n + 1)
+    assert s.simplify() == E*(factorial(n) - lowergamma(n + 1, 1))
+
+
+def test_Sum_dummy_eq():
+    assert not Sum(x, (x, a, b)).dummy_eq(1)
+    assert not Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, b), (a, 1, 2)))
+    assert not Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, c)))
+    assert Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, b)))
+    d = Dummy()
+    assert Sum(x, (x, a, d)).dummy_eq(Sum(x, (x, a, c)), c)
+    assert not Sum(x, (x, a, d)).dummy_eq(Sum(x, (x, a, c)))
+    assert Sum(x, (x, a, c)).dummy_eq(Sum(y, (y, a, c)))
+    assert Sum(x, (x, a, d)).dummy_eq(Sum(y, (y, a, c)), c)
+    assert not Sum(x, (x, a, d)).dummy_eq(Sum(y, (y, a, c)))
+
+
+def test_issue_15852():
+    assert summation(x**y*y, (y, -oo, oo)).doit() == Sum(x**y*y, (y, -oo, oo))
+
+
+def test_exceptions():
+    S = Sum(x, (x, a, b))
+    raises(ValueError, lambda: S.change_index(x, x**2, y))
+    S = Sum(x, (x, a, b), (x, 1, 4))
+    raises(ValueError, lambda: S.index(x))
+    S = Sum(x, (x, a, b), (y, 1, 4))
+    raises(ValueError, lambda: S.reorder([x]))
+    S = Sum(x, (x, y, b), (y, 1, 4))
+    raises(ReorderError, lambda: S.reorder_limit(0, 1))
+    S = Sum(x*y, (x, a, b), (y, 1, 4))
+    raises(NotImplementedError, lambda: S.is_convergent())
+
+
+def test_sumproducts_assumptions():
+    M = Symbol('M', integer=True, positive=True)
+
+    m = Symbol('m', integer=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, -M, M)).is_positive is None
+        assert func(m, (m, -M, M)).is_nonpositive is None
+        assert func(m, (m, -M, M)).is_negative is None
+        assert func(m, (m, -M, M)).is_nonnegative is None
+        assert func(m, (m, -M, M)).is_finite is True
+
+    m = Symbol('m', integer=True, nonnegative=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, 0, M)).is_positive is None
+        assert func(m, (m, 0, M)).is_nonpositive is None
+        assert func(m, (m, 0, M)).is_negative is False
+        assert func(m, (m, 0, M)).is_nonnegative is True
+        assert func(m, (m, 0, M)).is_finite is True
+
+    m = Symbol('m', integer=True, positive=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, 1, M)).is_positive is True
+        assert func(m, (m, 1, M)).is_nonpositive is False
+        assert func(m, (m, 1, M)).is_negative is False
+        assert func(m, (m, 1, M)).is_nonnegative is True
+        assert func(m, (m, 1, M)).is_finite is True
+
+    m = Symbol('m', integer=True, negative=True)
+    assert Sum(m, (m, -M, -1)).is_positive is False
+    assert Sum(m, (m, -M, -1)).is_nonpositive is True
+    assert Sum(m, (m, -M, -1)).is_negative is True
+    assert Sum(m, (m, -M, -1)).is_nonnegative is False
+    assert Sum(m, (m, -M, -1)).is_finite is True
+    assert Product(m, (m, -M, -1)).is_positive is None
+    assert Product(m, (m, -M, -1)).is_nonpositive is None
+    assert Product(m, (m, -M, -1)).is_negative is None
+    assert Product(m, (m, -M, -1)).is_nonnegative is None
+    assert Product(m, (m, -M, -1)).is_finite is True
+
+    m = Symbol('m', integer=True, nonpositive=True)
+    assert Sum(m, (m, -M, 0)).is_positive is False
+    assert Sum(m, (m, -M, 0)).is_nonpositive is True
+    assert Sum(m, (m, -M, 0)).is_negative is None
+    assert Sum(m, (m, -M, 0)).is_nonnegative is None
+    assert Sum(m, (m, -M, 0)).is_finite is True
+    assert Product(m, (m, -M, 0)).is_positive is None
+    assert Product(m, (m, -M, 0)).is_nonpositive is None
+    assert Product(m, (m, -M, 0)).is_negative is None
+    assert Product(m, (m, -M, 0)).is_nonnegative is None
+    assert Product(m, (m, -M, 0)).is_finite is True
+
+    m = Symbol('m', integer=True)
+    assert Sum(2, (m, 0, oo)).is_positive is None
+    assert Sum(2, (m, 0, oo)).is_nonpositive is None
+    assert Sum(2, (m, 0, oo)).is_negative is None
+    assert Sum(2, (m, 0, oo)).is_nonnegative is None
+    assert Sum(2, (m, 0, oo)).is_finite is None
+
+    assert Product(2, (m, 0, oo)).is_positive is None
+    assert Product(2, (m, 0, oo)).is_nonpositive is None
+    assert Product(2, (m, 0, oo)).is_negative is False
+    assert Product(2, (m, 0, oo)).is_nonnegative is None
+    assert Product(2, (m, 0, oo)).is_finite is None
+
+    assert Product(0, (x, M, M-1)).is_positive is True
+    assert Product(0, (x, M, M-1)).is_finite is True
+
+
+def test_expand_with_assumptions():
+    M = Symbol('M', integer=True, positive=True)
+    x = Symbol('x', positive=True)
+    m = Symbol('m', nonnegative=True)
+    assert log(Product(x**m, (m, 0, M))).expand() == Sum(m*log(x), (m, 0, M))
+    assert log(Product(exp(x**m), (m, 0, M))).expand() == Sum(x**m, (m, 0, M))
+    assert log(Product(x**m, (m, 0, M))).rewrite(Sum).expand() == Sum(m*log(x), (m, 0, M))
+    assert log(Product(exp(x**m), (m, 0, M))).rewrite(Sum).expand() == Sum(x**m, (m, 0, M))
+
+    n = Symbol('n', nonnegative=True)
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    assert log(Product(x**i*y**j, (i, 1, n), (j, 1, m))).expand() \
+        == Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+    m = Symbol('m', nonnegative=True, integer=True)
+    s = Sum(x**m, (m, 0, M))
+    s_as_product = s.rewrite(Product)
+    assert s_as_product.has(Product)
+    assert s_as_product == log(Product(exp(x**m), (m, 0, M)))
+    assert s_as_product.expand() == s
+    s5 = s.subs(M, 5)
+    s5_as_product = s5.rewrite(Product)
+    assert s5_as_product.has(Product)
+    assert s5_as_product.doit().expand() == s5.doit()
+
+
+def test_has_finite_limits():
+    x = Symbol('x')
+    assert Sum(1, (x, 1, 9)).has_finite_limits is True
+    assert Sum(1, (x, 1, oo)).has_finite_limits is False
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_finite_limits is None
+    M = Symbol('M', positive=True)
+    assert Sum(1, (x, 1, M)).has_finite_limits is True
+    x = Symbol('x', positive=True)
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_finite_limits is True
+
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_finite_limits is False
+
+def test_has_reversed_limits():
+    assert Sum(1, (x, 1, 1)).has_reversed_limits is False
+    assert Sum(1, (x, 1, 9)).has_reversed_limits is False
+    assert Sum(1, (x, 1, -9)).has_reversed_limits is True
+    assert Sum(1, (x, 1, 0)).has_reversed_limits is True
+    assert Sum(1, (x, 1, oo)).has_reversed_limits is False
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_reversed_limits is None
+    M = Symbol('M', positive=True, integer=True)
+    assert Sum(1, (x, 1, M)).has_reversed_limits is False
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_reversed_limits is False
+    M = Symbol('M', negative=True)
+    assert Sum(1, (x, 1, M)).has_reversed_limits is True
+
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_reversed_limits is True
+    assert Sum(1, (x, oo, oo)).has_reversed_limits is None
+
+
+def test_has_empty_sequence():
+    assert Sum(1, (x, 1, 1)).has_empty_sequence is False
+    assert Sum(1, (x, 1, 9)).has_empty_sequence is False
+    assert Sum(1, (x, 1, -9)).has_empty_sequence is False
+    assert Sum(1, (x, 1, 0)).has_empty_sequence is True
+    assert Sum(1, (x, y, y - 1)).has_empty_sequence is True
+    assert Sum(1, (x, 3, 2), (y, -oo, oo)).has_empty_sequence is True
+    assert Sum(1, (y, -oo, oo), (x, 3, 2)).has_empty_sequence is True
+    assert Sum(1, (x, oo, oo)).has_empty_sequence is False
+
+
+def test_empty_sequence():
+    assert Product(x*y, (x, -oo, oo), (y, 1, 0)).doit() == 1
+    assert Product(x*y, (y, 1, 0), (x, -oo, oo)).doit() == 1
+    assert Sum(x, (x, -oo, oo), (y, 1, 0)).doit() == 0
+    assert Sum(x, (y, 1, 0), (x, -oo, oo)).doit() == 0
+
+
+def test_issue_8016():
+    k = Symbol('k', integer=True)
+    n, m = symbols('n, m', integer=True, positive=True)
+    s = Sum(binomial(m, k)*binomial(m, n - k)*(-1)**k, (k, 0, n))
+    assert s.doit().simplify() == \
+        cos(pi*n/2)*gamma(m + 1)/gamma(n/2 + 1)/gamma(m - n/2 + 1)
+
+
+def test_issue_14313():
+    assert Sum(S.Half**floor(n/2), (n, 1, oo)).is_convergent()
+
+
+def test_issue_14563():
+    # The assertion was failing due to no assumptions methods in Sums and Product
+    assert 1 % Sum(1, (x, 0, 1)) == 1
+
+
+def test_issue_16735():
+    assert Sum(5**n/gamma(n+1), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14871():
+    assert Sum((Rational(1, 10))**n*rf(0, n)/factorial(n), (n, 0, oo)).rewrite(factorial).doit() == 1
+
+
+def test_issue_17165():
+    n = symbols("n", integer=True)
+    x = symbols('x')
+    s = (x*Sum(x**n, (n, -1, oo)))
+    ssimp = s.doit().simplify()
+
+    assert ssimp == Piecewise((-1/(x - 1), (x > -1) & (x < 1)),
+                              (x*Sum(x**n, (n, -1, oo)), True)), ssimp
+    assert ssimp.simplify() == ssimp
+
+
+def test_issue_19379():
+    assert Sum(factorial(n)/factorial(n + 2), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_20777():
+    assert Sum(exp(x*sin(n/m)), (n, 1, m)).doit() == Sum(exp(x*sin(n/m)), (n, 1, m))
+
+
+def test__dummy_with_inherited_properties_concrete():
+    x = Symbol('x')
+
+    from sympy.core.containers import Tuple
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 0, 5))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_nonnegative
+    assert d.is_extended_nonnegative
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 1, 9))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_positive
+    assert d.is_odd is None
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, -5, 5))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_positive is None
+    assert d.is_extended_nonnegative is None
+    assert d.is_odd is None
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, -1.5, 1.5))
+    assert d.is_real
+    assert d.is_integer is None
+    assert d.is_positive is None
+    assert d.is_extended_nonnegative is None
+
+    N = Symbol('N', integer=True, positive=True)
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 2, N))
+    assert d.is_real
+    assert d.is_positive
+    assert d.is_integer
+
+    # Return None if no assumptions are added
+    N = Symbol('N', integer=True, positive=True)
+    d = _dummy_with_inherited_properties_concrete(Tuple(N, 2, 4))
+    assert d is None
+
+    x = Symbol('x', negative=True)
+    raises(InconsistentAssumptions,
+           lambda: _dummy_with_inherited_properties_concrete(Tuple(x, 1, 5)))
+
+
+def test_matrixsymbol_summation_numerical_limits():
+    A = MatrixSymbol('A', 3, 3)
+    n = Symbol('n', integer=True)
+
+    assert Sum(A**n, (n, 0, 2)).doit() == Identity(3) + A + A**2
+    assert Sum(A, (n, 0, 2)).doit() == 3*A
+    assert Sum(n*A, (n, 0, 2)).doit() == 3*A
+
+    B = Matrix([[0, n, 0], [-1, 0, 0], [0, 0, 2]])
+    ans = Matrix([[0, 6, 0], [-4, 0, 0], [0, 0, 8]]) + 4*A
+    assert Sum(A+B, (n, 0, 3)).doit() == ans
+    ans = A*Matrix([[0, 6, 0], [-4, 0, 0], [0, 0, 8]])
+    assert Sum(A*B, (n, 0, 3)).doit() == ans
+
+    ans = (A**2*Matrix([[-2, 0, 0], [0,-2, 0], [0, 0, 4]]) +
+           A**3*Matrix([[0, -9, 0], [3, 0, 0], [0, 0, 8]]) +
+           A*Matrix([[0, 1, 0], [-1, 0, 0], [0, 0, 2]]))
+    assert Sum(A**n*B**n, (n, 1, 3)).doit() == ans
+
+
+def test_issue_21651():
+    i = Symbol('i')
+    a = Sum(floor(2*2**(-i)), (i, S.One, 2))
+    assert a.doit() == S.One
+
+
+@XFAIL
+def test_matrixsymbol_summation_symbolic_limits():
+    N = Symbol('N', integer=True, positive=True)
+
+    A = MatrixSymbol('A', 3, 3)
+    n = Symbol('n', integer=True)
+    assert Sum(A, (n, 0, N)).doit() == (N+1)*A
+    assert Sum(n*A, (n, 0, N)).doit() == (N**2/2+N/2)*A
+
+
+def test_summation_by_residues():
+    x = Symbol('x')
+
+    # Examples from Nakhle H. Asmar, Loukas Grafakos,
+    # Complex Analysis with Applications
+    assert eval_sum_residue(1 / (x**2 + 1), (x, -oo, oo)) == pi/tanh(pi)
+    assert eval_sum_residue(1 / x**6, (x, S(1), oo)) == pi**6/945
+    assert eval_sum_residue(1 / (x**2 + 9), (x, -oo, oo)) == pi/(3*tanh(3*pi))
+    assert eval_sum_residue(1 / (x**2 + 1)**2, (x, -oo, oo)).cancel() == \
+        (-pi**2*tanh(pi)**2 + pi*tanh(pi) + pi**2)/(2*tanh(pi)**2)
+    assert eval_sum_residue(x**2 / (x**2 + 1)**2, (x, -oo, oo)).cancel() == \
+        (-pi**2 + pi*tanh(pi) + pi**2*tanh(pi)**2)/(2*tanh(pi)**2)
+    assert eval_sum_residue(1 / (4*x**2 - 1), (x, -oo, oo)) == 0
+    assert eval_sum_residue(x**2 / (x**2 - S(1)/4)**2, (x, -oo, oo)) == pi**2/2
+    assert eval_sum_residue(1 / (4*x**2 - 1)**2, (x, -oo, oo)) == pi**2/8
+    assert eval_sum_residue(1 / ((x - S(1)/2)**2 + 1), (x, -oo, oo)) == pi*tanh(pi)
+    assert eval_sum_residue(1 / x**2, (x, S(1), oo)) == pi**2/6
+    assert eval_sum_residue(1 / x**4, (x, S(1), oo)) == pi**4/90
+    assert eval_sum_residue(1 / x**2 / (x**2 + 4), (x, S(1), oo)) == \
+        -pi*(-pi/12 - 1/(16*pi) + 1/(8*tanh(2*pi)))/2
+
+    # Some examples made from 1 / (x**2 + 1)
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(0), oo)) == \
+        S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(1), oo)) == \
+        -S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(-1), oo)) == \
+        1 + pi/(2*tanh(pi))
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, -oo, oo)) == \
+        pi/sinh(pi)
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(0), oo)) == \
+        pi/(2*sinh(pi)) + S(1)/2
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(1), oo)) == \
+        -S(1)/2 + pi/(2*sinh(pi))
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(-1), oo)) == \
+        pi/(2*sinh(pi))
+
+    # Some examples made from shifting of 1 / (x**2 + 1)
+    assert eval_sum_residue(1 / (x**2 + 2*x + 2), (x, S(-1), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 4*x + 5), (x, S(-2), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 - 2*x + 2), (x, S(1), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 - 4*x + 5), (x, S(2), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue((-1)**x * -1 / (x**2 + 2*x + 2), (x, S(-1), oo)) ==  S(1)/2 + pi/(2*sinh(pi))
+    assert eval_sum_residue((-1)**x * -1 / (x**2 -2*x + 2), (x, S(1), oo)) == S(1)/2 + pi/(2*sinh(pi))
+
+    # Some examples made from 1 / x**2
+    assert eval_sum_residue(1 / x**2, (x, S(2), oo)) == -1 + pi**2/6
+    assert eval_sum_residue(1 / x**2, (x, S(3), oo)) == -S(5)/4 + pi**2/6
+    assert eval_sum_residue((-1)**x / x**2, (x, S(1), oo)) == -pi**2/12
+    assert eval_sum_residue((-1)**x / x**2, (x, S(2), oo)) == 1 - pi**2/12
+
+
+@slow
+def test_summation_by_residues_failing():
+    x = Symbol('x')
+
+    # Failing because of the bug in residue computation
+    assert eval_sum_residue(x**2 / (x**4 + 1), (x, S(1), oo))
+    assert eval_sum_residue(1 / ((x - 1)*(x - 2) + 1), (x, -oo, oo)) != 0
+
+
+def test_process_limits():
+    from sympy.concrete.expr_with_limits import _process_limits
+
+    # these should be (x, Range(3)) not Range(3)
+    raises(ValueError, lambda: _process_limits(
+        Range(3), discrete=True))
+    raises(ValueError, lambda: _process_limits(
+        Range(3), discrete=False))
+    # these should be (x, union) not union
+    # (but then we would get a TypeError because we don't
+    # handle non-contiguous sets: see below use of `union`)
+    union = Or(x < 1, x > 3).as_set()
+    raises(ValueError, lambda: _process_limits(
+        union, discrete=True))
+    raises(ValueError, lambda: _process_limits(
+        union, discrete=False))
+
+    # error not triggered if not needed
+    assert _process_limits((x, 1, 2)) == ([(x, 1, 2)], 1)
+
+    # this equivalence is used to detect Reals in _process_limits
+    assert isinstance(S.Reals, Interval)
+
+    C = Integral  # continuous limits
+    assert C(x, x >= 5) == C(x, (x, 5, oo))
+    assert C(x, x < 3) == C(x, (x, -oo, 3))
+    ans = C(x, (x, 0, 3))
+    assert C(x, And(x >= 0, x < 3)) == ans
+    assert C(x, (x, Interval.Ropen(0, 3))) == ans
+    raises(TypeError, lambda: C(x, (x, Range(3))))
+
+    # discrete limits
+    for D in (Sum, Product):
+        r, ans = Range(3, 10, 2), D(2*x + 3, (x, 0, 3))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        r, ans = Range(3, oo, 2), D(2*x + 3, (x, 0, oo))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        r, ans = Range(-oo, 5, 2), D(3 - 2*x, (x, 0, oo))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        raises(TypeError, lambda: D(x, x > 0))
+        raises(ValueError, lambda: D(x, Interval(1, 3)))
+        raises(NotImplementedError, lambda: D(x, (x, union)))
+
+
+def test_pr_22677():
+    b = Symbol('b', integer=True, positive=True)
+    assert Sum(1/x**2,(x, 0, b)).doit() == Sum(x**(-2), (x, 0, b))
+    assert Sum(1/(x - b)**2,(x, 0, b-1)).doit() == Sum(
+        (-b + x)**(-2), (x, 0, b - 1))
+
+
+def test_issue_23952():
+    p, q = symbols("p q", real=True, nonnegative=True)
+    k1, k2 = symbols("k1 k2", integer=True, nonnegative=True)
+    n = Symbol("n", integer=True, positive=True)
+    expr = Sum(abs(k1 - k2)*p**k1 *(1 - q)**(n - k2),
+        (k1, 0, n), (k2, 0, n))
+    assert expr.subs(p,0).subs(q,1).subs(n, 3).doit() == 3

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/common.py

@@ -0,0 +1,3263 @@
+"""
+A module contining deprecated matrix mixin classes.
+
+The classes in this module are deprecated and will be removed in a future
+release. They are kept here for backwards compatibility in case downstream
+code was subclassing them.
+
+Importing anything else from this module is deprecated so anything here
+should either not be used or should be imported from somewhere else.
+"""
+
+from collections import defaultdict
+from collections.abc import Iterable
+from inspect import isfunction
+from functools import reduce
+
+from sympy.assumptions.refine import refine
+from sympy.core import SympifyError, Add
+from sympy.core.basic import Atom
+from sympy.core.decorators import call_highest_priority
+from sympy.core.logic import fuzzy_and, FuzzyBool
+from sympy.core.numbers import Integer
+from sympy.core.mod import Mod
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import Abs, re, im
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from .utilities import _dotprodsimp, _simplify
+from sympy.polys.polytools import Poly
+from sympy.utilities.iterables import flatten, is_sequence
+from sympy.utilities.misc import as_int, filldedent
+from sympy.tensor.array import NDimArray
+
+from .utilities import _get_intermediate_simp_bool
+
+
+# These exception types were previously defined in this module but were moved
+# to exceptions.py. We reimport them here for backwards compatibility in case
+# downstream code was importing them from here.
+from .exceptions import ( # noqa: F401
+    MatrixError, ShapeError, NonSquareMatrixError, NonInvertibleMatrixError,
+    NonPositiveDefiniteMatrixError
+)
+
+
+_DEPRECATED_MIXINS = (
+    'MatrixShaping',
+    'MatrixSpecial',
+    'MatrixProperties',
+    'MatrixOperations',
+    'MatrixArithmetic',
+    'MatrixCommon',
+    'MatrixDeterminant',
+    'MatrixReductions',
+    'MatrixSubspaces',
+    'MatrixEigen',
+    'MatrixCalculus',
+    'MatrixDeprecated',
+)
+
+
+class _MatrixDeprecatedMeta(type):
+
+    #
+    # Override the default __instancecheck__ implementation to ensure that
+    # e.g. isinstance(M, MatrixCommon) still works when M is one of the
+    # matrix classes. Matrix no longer inherits from MatrixCommon so
+    # isinstance(M, MatrixCommon) would now return False by default.
+    #
+    # There were lots of places in the codebase where this was being done
+    # so it seems likely that downstream code may be doing it too. All use
+    # of these mixins is deprecated though so we give a deprecation warning
+    # unconditionally if they are being used with isinstance.
+    #
+    # Any code seeing this deprecation warning should be changed to use
+    # isinstance(M, MatrixBase) instead which also works in previous versions
+    # of SymPy.
+    #
+
+    def __instancecheck__(cls, instance):
+
+        sympy_deprecation_warning(
+            f"""
+            Checking whether an object is an instance of {cls.__name__} is
+            deprecated.
+
+            Use `isinstance(obj, Matrix)` instead of `isinstance(obj, {cls.__name__})`.
+            """,
+            deprecated_since_version="1.13",
+            active_deprecations_target="deprecated-matrix-mixins",
+            stacklevel=3,
+        )
+
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.matrices.matrices import (
+            MatrixDeterminant,
+            MatrixReductions,
+            MatrixSubspaces,
+            MatrixEigen,
+            MatrixCalculus,
+            MatrixDeprecated
+        )
+
+        all_mixins = (
+            MatrixRequired,
+            MatrixShaping,
+            MatrixSpecial,
+            MatrixProperties,
+            MatrixOperations,
+            MatrixArithmetic,
+            MatrixCommon,
+            MatrixDeterminant,
+            MatrixReductions,
+            MatrixSubspaces,
+            MatrixEigen,
+            MatrixCalculus,
+            MatrixDeprecated
+        )
+
+        if cls in all_mixins and isinstance(instance, MatrixBase):
+            return True
+        else:
+            return super().__instancecheck__(instance)
+
+
+class MatrixRequired(metaclass=_MatrixDeprecatedMeta):
+    """Deprecated mixin class for making matrix classes."""
+
+    rows = None  # type: int
+    cols = None  # type: int
+    _simplify = None
+
+    def __init_subclass__(cls, **kwargs):
+
+        # Warn if any downstream code is subclassing this class or any of the
+        # deprecated mixin classes that are all ultimately subclasses of this
+        # class.
+        #
+        # We don't want to warn about the deprecated mixins themselves being
+        # created, but only about them being used as mixins by downstream code.
+        # Otherwise just importing this module would trigger a warning.
+        # Ultimately the whole module should be deprecated and removed but for
+        # SymPy 1.13 it is premature to do that given that this module was the
+        # main way to import matrix exception types in all previous versions.
+
+        if cls.__name__ not in _DEPRECATED_MIXINS:
+            sympy_deprecation_warning(
+                f"""
+                Inheriting from the Matrix mixin classes is deprecated.
+
+                The class {cls.__name__} is subclassing a deprecated mixin.
+                """,
+                deprecated_since_version="1.13",
+                active_deprecations_target="deprecated-matrix-mixins",
+                stacklevel=3,
+            )
+
+        super().__init_subclass__(**kwargs)
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        """`_new` must, at minimum, be callable as
+        `_new(rows, cols, mat) where mat is a flat list of the
+        elements of the matrix."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __eq__(self, other):
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __getitem__(self, key):
+        """Implementations of __getitem__ should accept ints, in which
+        case the matrix is indexed as a flat list, tuples (i,j) in which
+        case the (i,j) entry is returned, slices, or mixed tuples (a,b)
+        where a and b are any combination of slices and integers."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    def __len__(self):
+        """The total number of entries in the matrix."""
+        raise NotImplementedError("Subclasses must implement this.")
+
+    @property
+    def shape(self):
+        raise NotImplementedError("Subclasses must implement this.")
+
+
+class MatrixShaping(MatrixRequired):
+    """Provides basic matrix shaping and extracting of submatrices"""
+
+    def _eval_col_del(self, col):
+        def entry(i, j):
+            return self[i, j] if j < col else self[i, j + 1]
+        return self._new(self.rows, self.cols - 1, entry)
+
+    def _eval_col_insert(self, pos, other):
+
+        def entry(i, j):
+            if j < pos:
+                return self[i, j]
+            elif pos <= j < pos + other.cols:
+                return other[i, j - pos]
+            return self[i, j - other.cols]
+
+        return self._new(self.rows, self.cols + other.cols, entry)
+
+    def _eval_col_join(self, other):
+        rows = self.rows
+
+        def entry(i, j):
+            if i < rows:
+                return self[i, j]
+            return other[i - rows, j]
+
+        return classof(self, other)._new(self.rows + other.rows, self.cols,
+                                         entry)
+
+    def _eval_extract(self, rowsList, colsList):
+        mat = list(self)
+        cols = self.cols
+        indices = (i * cols + j for i in rowsList for j in colsList)
+        return self._new(len(rowsList), len(colsList),
+                         [mat[i] for i in indices])
+
+    def _eval_get_diag_blocks(self):
+        sub_blocks = []
+
+        def recurse_sub_blocks(M):
+            i = 1
+            while i <= M.shape[0]:
+                if i == 1:
+                    to_the_right = M[0, i:]
+                    to_the_bottom = M[i:, 0]
+                else:
+                    to_the_right = M[:i, i:]
+                    to_the_bottom = M[i:, :i]
+                if any(to_the_right) or any(to_the_bottom):
+                    i += 1
+                    continue
+                else:
+                    sub_blocks.append(M[:i, :i])
+                    if M.shape == M[:i, :i].shape:
+                        return
+                    else:
+                        recurse_sub_blocks(M[i:, i:])
+                        return
+
+        recurse_sub_blocks(self)
+        return sub_blocks
+
+    def _eval_row_del(self, row):
+        def entry(i, j):
+            return self[i, j] if i < row else self[i + 1, j]
+        return self._new(self.rows - 1, self.cols, entry)
+
+    def _eval_row_insert(self, pos, other):
+        entries = list(self)
+        insert_pos = pos * self.cols
+        entries[insert_pos:insert_pos] = list(other)
+        return self._new(self.rows + other.rows, self.cols, entries)
+
+    def _eval_row_join(self, other):
+        cols = self.cols
+
+        def entry(i, j):
+            if j < cols:
+                return self[i, j]
+            return other[i, j - cols]
+
+        return classof(self, other)._new(self.rows, self.cols + other.cols,
+                                         entry)
+
+    def _eval_tolist(self):
+        return [list(self[i,:]) for i in range(self.rows)]
+
+    def _eval_todok(self):
+        dok = {}
+        rows, cols = self.shape
+        for i in range(rows):
+            for j in range(cols):
+                val = self[i, j]
+                if val != self.zero:
+                    dok[i, j] = val
+        return dok
+
+    def _eval_vec(self):
+        rows = self.rows
+
+        def entry(n, _):
+            # we want to read off the columns first
+            j = n // rows
+            i = n - j * rows
+            return self[i, j]
+
+        return self._new(len(self), 1, entry)
+
+    def _eval_vech(self, diagonal):
+        c = self.cols
+        v = []
+        if diagonal:
+            for j in range(c):
+                for i in range(j, c):
+                    v.append(self[i, j])
+        else:
+            for j in range(c):
+                for i in range(j + 1, c):
+                    v.append(self[i, j])
+        return self._new(len(v), 1, v)
+
+    def col_del(self, col):
+        """Delete the specified column."""
+        if col < 0:
+            col += self.cols
+        if not 0 <= col < self.cols:
+            raise IndexError("Column {} is out of range.".format(col))
+        return self._eval_col_del(col)
+
+    def col_insert(self, pos, other):
+        """Insert one or more columns at the given column position.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(3, 1)
+        >>> M.col_insert(1, V)
+        Matrix([
+        [0, 1, 0, 0],
+        [0, 1, 0, 0],
+        [0, 1, 0, 0]])
+
+        See Also
+        ========
+
+        col
+        row_insert
+        """
+        # Allows you to build a matrix even if it is null matrix
+        if not self:
+            return type(self)(other)
+
+        pos = as_int(pos)
+
+        if pos < 0:
+            pos = self.cols + pos
+        if pos < 0:
+            pos = 0
+        elif pos > self.cols:
+            pos = self.cols
+
+        if self.rows != other.rows:
+            raise ShapeError(
+                "The matrices have incompatible number of rows ({} and {})"
+                .format(self.rows, other.rows))
+
+        return self._eval_col_insert(pos, other)
+
+    def col_join(self, other):
+        """Concatenates two matrices along self's last and other's first row.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(1, 3)
+        >>> M.col_join(V)
+        Matrix([
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+        [1, 1, 1]])
+
+        See Also
+        ========
+
+        col
+        row_join
+        """
+        # A null matrix can always be stacked (see  #10770)
+        if self.rows == 0 and self.cols != other.cols:
+            return self._new(0, other.cols, []).col_join(other)
+
+        if self.cols != other.cols:
+            raise ShapeError(
+                "The matrices have incompatible number of columns ({} and {})"
+                .format(self.cols, other.cols))
+        return self._eval_col_join(other)
+
+    def col(self, j):
+        """Elementary column selector.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> eye(2).col(0)
+        Matrix([
+        [1],
+        [0]])
+
+        See Also
+        ========
+
+        row
+        col_del
+        col_join
+        col_insert
+        """
+        return self[:, j]
+
+    def extract(self, rowsList, colsList):
+        r"""Return a submatrix by specifying a list of rows and columns.
+        Negative indices can be given. All indices must be in the range
+        $-n \le i < n$ where $n$ is the number of rows or columns.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(4, 3, range(12))
+        >>> m
+        Matrix([
+        [0,  1,  2],
+        [3,  4,  5],
+        [6,  7,  8],
+        [9, 10, 11]])
+        >>> m.extract([0, 1, 3], [0, 1])
+        Matrix([
+        [0,  1],
+        [3,  4],
+        [9, 10]])
+
+        Rows or columns can be repeated:
+
+        >>> m.extract([0, 0, 1], [-1])
+        Matrix([
+        [2],
+        [2],
+        [5]])
+
+        Every other row can be taken by using range to provide the indices:
+
+        >>> m.extract(range(0, m.rows, 2), [-1])
+        Matrix([
+        [2],
+        [8]])
+
+        RowsList or colsList can also be a list of booleans, in which case
+        the rows or columns corresponding to the True values will be selected:
+
+        >>> m.extract([0, 1, 2, 3], [True, False, True])
+        Matrix([
+        [0,  2],
+        [3,  5],
+        [6,  8],
+        [9, 11]])
+        """
+
+        if not is_sequence(rowsList) or not is_sequence(colsList):
+            raise TypeError("rowsList and colsList must be iterable")
+        # ensure rowsList and colsList are lists of integers
+        if rowsList and all(isinstance(i, bool) for i in rowsList):
+            rowsList = [index for index, item in enumerate(rowsList) if item]
+        if colsList and all(isinstance(i, bool) for i in colsList):
+            colsList = [index for index, item in enumerate(colsList) if item]
+
+        # ensure everything is in range
+        rowsList = [a2idx(k, self.rows) for k in rowsList]
+        colsList = [a2idx(k, self.cols) for k in colsList]
+
+        return self._eval_extract(rowsList, colsList)
+
+    def get_diag_blocks(self):
+        """Obtains the square sub-matrices on the main diagonal of a square matrix.
+
+        Useful for inverting symbolic matrices or solving systems of
+        linear equations which may be decoupled by having a block diagonal
+        structure.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y, z
+        >>> A = Matrix([[1, 3, 0, 0], [y, z*z, 0, 0], [0, 0, x, 0], [0, 0, 0, 0]])
+        >>> a1, a2, a3 = A.get_diag_blocks()
+        >>> a1
+        Matrix([
+        [1,    3],
+        [y, z**2]])
+        >>> a2
+        Matrix([[x]])
+        >>> a3
+        Matrix([[0]])
+
+        """
+        return self._eval_get_diag_blocks()
+
+    @classmethod
+    def hstack(cls, *args):
+        """Return a matrix formed by joining args horizontally (i.e.
+        by repeated application of row_join).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, eye
+        >>> Matrix.hstack(eye(2), 2*eye(2))
+        Matrix([
+        [1, 0, 2, 0],
+        [0, 1, 0, 2]])
+        """
+        if len(args) == 0:
+            return cls._new()
+
+        kls = type(args[0])
+        return reduce(kls.row_join, args)
+
+    def reshape(self, rows, cols):
+        """Reshape the matrix. Total number of elements must remain the same.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 3, lambda i, j: 1)
+        >>> m
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1]])
+        >>> m.reshape(1, 6)
+        Matrix([[1, 1, 1, 1, 1, 1]])
+        >>> m.reshape(3, 2)
+        Matrix([
+        [1, 1],
+        [1, 1],
+        [1, 1]])
+
+        """
+        if self.rows * self.cols != rows * cols:
+            raise ValueError("Invalid reshape parameters %d %d" % (rows, cols))
+        return self._new(rows, cols, lambda i, j: self[i * cols + j])
+
+    def row_del(self, row):
+        """Delete the specified row."""
+        if row < 0:
+            row += self.rows
+        if not 0 <= row < self.rows:
+            raise IndexError("Row {} is out of range.".format(row))
+
+        return self._eval_row_del(row)
+
+    def row_insert(self, pos, other):
+        """Insert one or more rows at the given row position.
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(1, 3)
+        >>> M.row_insert(1, V)
+        Matrix([
+        [0, 0, 0],
+        [1, 1, 1],
+        [0, 0, 0],
+        [0, 0, 0]])
+
+        See Also
+        ========
+
+        row
+        col_insert
+        """
+        # Allows you to build a matrix even if it is null matrix
+        if not self:
+            return self._new(other)
+
+        pos = as_int(pos)
+
+        if pos < 0:
+            pos = self.rows + pos
+        if pos < 0:
+            pos = 0
+        elif pos > self.rows:
+            pos = self.rows
+
+        if self.cols != other.cols:
+            raise ShapeError(
+                "The matrices have incompatible number of columns ({} and {})"
+                .format(self.cols, other.cols))
+
+        return self._eval_row_insert(pos, other)
+
+    def row_join(self, other):
+        """Concatenates two matrices along self's last and rhs's first column
+
+        Examples
+        ========
+
+        >>> from sympy import zeros, ones
+        >>> M = zeros(3)
+        >>> V = ones(3, 1)
+        >>> M.row_join(V)
+        Matrix([
+        [0, 0, 0, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 1]])
+
+        See Also
+        ========
+
+        row
+        col_join
+        """
+        # A null matrix can always be stacked (see  #10770)
+        if self.cols == 0 and self.rows != other.rows:
+            return self._new(other.rows, 0, []).row_join(other)
+
+        if self.rows != other.rows:
+            raise ShapeError(
+                "The matrices have incompatible number of rows ({} and {})"
+                .format(self.rows, other.rows))
+        return self._eval_row_join(other)
+
+    def diagonal(self, k=0):
+        """Returns the kth diagonal of self. The main diagonal
+        corresponds to `k=0`; diagonals above and below correspond to
+        `k > 0` and `k < 0`, respectively. The values of `self[i, j]`
+        for which `j - i = k`, are returned in order of increasing
+        `i + j`, starting with `i + j = |k|`.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(3, 3, lambda i, j: j - i); m
+        Matrix([
+        [ 0,  1, 2],
+        [-1,  0, 1],
+        [-2, -1, 0]])
+        >>> _.diagonal()
+        Matrix([[0, 0, 0]])
+        >>> m.diagonal(1)
+        Matrix([[1, 1]])
+        >>> m.diagonal(-2)
+        Matrix([[-2]])
+
+        Even though the diagonal is returned as a Matrix, the element
+        retrieval can be done with a single index:
+
+        >>> Matrix.diag(1, 2, 3).diagonal()[1]  # instead of [0, 1]
+        2
+
+        See Also
+        ========
+
+        diag
+        """
+        rv = []
+        k = as_int(k)
+        r = 0 if k > 0 else -k
+        c = 0 if r else k
+        while True:
+            if r == self.rows or c == self.cols:
+                break
+            rv.append(self[r, c])
+            r += 1
+            c += 1
+        if not rv:
+            raise ValueError(filldedent('''
+            The %s diagonal is out of range [%s, %s]''' % (
+            k, 1 - self.rows, self.cols - 1)))
+        return self._new(1, len(rv), rv)
+
+    def row(self, i):
+        """Elementary row selector.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> eye(2).row(0)
+        Matrix([[1, 0]])
+
+        See Also
+        ========
+
+        col
+        row_del
+        row_join
+        row_insert
+        """
+        return self[i, :]
+
+    @property
+    def shape(self):
+        """The shape (dimensions) of the matrix as the 2-tuple (rows, cols).
+
+        Examples
+        ========
+
+        >>> from sympy import zeros
+        >>> M = zeros(2, 3)
+        >>> M.shape
+        (2, 3)
+        >>> M.rows
+        2
+        >>> M.cols
+        3
+        """
+        return (self.rows, self.cols)
+
+    def todok(self):
+        """Return the matrix as dictionary of keys.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix.eye(3)
+        >>> M.todok()
+        {(0, 0): 1, (1, 1): 1, (2, 2): 1}
+        """
+        return self._eval_todok()
+
+    def tolist(self):
+        """Return the Matrix as a nested Python list.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, ones
+        >>> m = Matrix(3, 3, range(9))
+        >>> m
+        Matrix([
+        [0, 1, 2],
+        [3, 4, 5],
+        [6, 7, 8]])
+        >>> m.tolist()
+        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+        >>> ones(3, 0).tolist()
+        [[], [], []]
+
+        When there are no rows then it will not be possible to tell how
+        many columns were in the original matrix:
+
+        >>> ones(0, 3).tolist()
+        []
+
+        """
+        if not self.rows:
+            return []
+        if not self.cols:
+            return [[] for i in range(self.rows)]
+        return self._eval_tolist()
+
+    def todod(M):
+        """Returns matrix as dict of dicts containing non-zero elements of the Matrix
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[0, 1],[0, 3]])
+        >>> A
+        Matrix([
+        [0, 1],
+        [0, 3]])
+        >>> A.todod()
+        {0: {1: 1}, 1: {1: 3}}
+
+
+        """
+        rowsdict = {}
+        Mlol = M.tolist()
+        for i, Mi in enumerate(Mlol):
+            row = {j: Mij for j, Mij in enumerate(Mi) if Mij}
+            if row:
+                rowsdict[i] = row
+        return rowsdict
+
+    def vec(self):
+        """Return the Matrix converted into a one column matrix by stacking columns
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m=Matrix([[1, 3], [2, 4]])
+        >>> m
+        Matrix([
+        [1, 3],
+        [2, 4]])
+        >>> m.vec()
+        Matrix([
+        [1],
+        [2],
+        [3],
+        [4]])
+
+        See Also
+        ========
+
+        vech
+        """
+        return self._eval_vec()
+
+    def vech(self, diagonal=True, check_symmetry=True):
+        """Reshapes the matrix into a column vector by stacking the
+        elements in the lower triangle.
+
+        Parameters
+        ==========
+
+        diagonal : bool, optional
+            If ``True``, it includes the diagonal elements.
+
+        check_symmetry : bool, optional
+            If ``True``, it checks whether the matrix is symmetric.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m=Matrix([[1, 2], [2, 3]])
+        >>> m
+        Matrix([
+        [1, 2],
+        [2, 3]])
+        >>> m.vech()
+        Matrix([
+        [1],
+        [2],
+        [3]])
+        >>> m.vech(diagonal=False)
+        Matrix([[2]])
+
+        Notes
+        =====
+
+        This should work for symmetric matrices and ``vech`` can
+        represent symmetric matrices in vector form with less size than
+        ``vec``.
+
+        See Also
+        ========
+
+        vec
+        """
+        if not self.is_square:
+            raise NonSquareMatrixError
+
+        if check_symmetry and not self.is_symmetric():
+            raise ValueError("The matrix is not symmetric.")
+
+        return self._eval_vech(diagonal)
+
+    @classmethod
+    def vstack(cls, *args):
+        """Return a matrix formed by joining args vertically (i.e.
+        by repeated application of col_join).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, eye
+        >>> Matrix.vstack(eye(2), 2*eye(2))
+        Matrix([
+        [1, 0],
+        [0, 1],
+        [2, 0],
+        [0, 2]])
+        """
+        if len(args) == 0:
+            return cls._new()
+
+        kls = type(args[0])
+        return reduce(kls.col_join, args)
+
+
+class MatrixSpecial(MatrixRequired):
+    """Construction of special matrices"""
+
+    @classmethod
+    def _eval_diag(cls, rows, cols, diag_dict):
+        """diag_dict is a defaultdict containing
+        all the entries of the diagonal matrix."""
+        def entry(i, j):
+            return diag_dict[(i, j)]
+        return cls._new(rows, cols, entry)
+
+    @classmethod
+    def _eval_eye(cls, rows, cols):
+        vals = [cls.zero]*(rows*cols)
+        vals[::cols+1] = [cls.one]*min(rows, cols)
+        return cls._new(rows, cols, vals, copy=False)
+
+    @classmethod
+    def _eval_jordan_block(cls, size: int, eigenvalue, band='upper'):
+        if band == 'lower':
+            def entry(i, j):
+                if i == j:
+                    return eigenvalue
+                elif j + 1 == i:
+                    return cls.one
+                return cls.zero
+        else:
+            def entry(i, j):
+                if i == j:
+                    return eigenvalue
+                elif i + 1 == j:
+                    return cls.one
+                return cls.zero
+        return cls._new(size, size, entry)
+
+    @classmethod
+    def _eval_ones(cls, rows, cols):
+        def entry(i, j):
+            return cls.one
+        return cls._new(rows, cols, entry)
+
+    @classmethod
+    def _eval_zeros(cls, rows, cols):
+        return cls._new(rows, cols, [cls.zero]*(rows*cols), copy=False)
+
+    @classmethod
+    def _eval_wilkinson(cls, n):
+        def entry(i, j):
+            return cls.one if i + 1 == j else cls.zero
+
+        D = cls._new(2*n + 1, 2*n + 1, entry)
+
+        wminus = cls.diag(list(range(-n, n + 1)), unpack=True) + D + D.T
+        wplus = abs(cls.diag(list(range(-n, n + 1)), unpack=True)) + D + D.T
+
+        return wminus, wplus
+
+    @classmethod
+    def diag(kls, *args, strict=False, unpack=True, rows=None, cols=None, **kwargs):
+        """Returns a matrix with the specified diagonal.
+        If matrices are passed, a block-diagonal matrix
+        is created (i.e. the "direct sum" of the matrices).
+
+        kwargs
+        ======
+
+        rows : rows of the resulting matrix; computed if
+               not given.
+
+        cols : columns of the resulting matrix; computed if
+               not given.
+
+        cls : class for the resulting matrix
+
+        unpack : bool which, when True (default), unpacks a single
+        sequence rather than interpreting it as a Matrix.
+
+        strict : bool which, when False (default), allows Matrices to
+        have variable-length rows.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> Matrix.diag(1, 2, 3)
+        Matrix([
+        [1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3]])
+
+        The current default is to unpack a single sequence. If this is
+        not desired, set `unpack=False` and it will be interpreted as
+        a matrix.
+
+        >>> Matrix.diag([1, 2, 3]) == Matrix.diag(1, 2, 3)
+        True
+
+        When more than one element is passed, each is interpreted as
+        something to put on the diagonal. Lists are converted to
+        matrices. Filling of the diagonal always continues from
+        the bottom right hand corner of the previous item: this
+        will create a block-diagonal matrix whether the matrices
+        are square or not.
+
+        >>> col = [1, 2, 3]
+        >>> row = [[4, 5]]
+        >>> Matrix.diag(col, row)
+        Matrix([
+        [1, 0, 0],
+        [2, 0, 0],
+        [3, 0, 0],
+        [0, 4, 5]])
+
+        When `unpack` is False, elements within a list need not all be
+        of the same length. Setting `strict` to True would raise a
+        ValueError for the following:
+
+        >>> Matrix.diag([[1, 2, 3], [4, 5], [6]], unpack=False)
+        Matrix([
+        [1, 2, 3],
+        [4, 5, 0],
+        [6, 0, 0]])
+
+        The type of the returned matrix can be set with the ``cls``
+        keyword.
+
+        >>> from sympy import ImmutableMatrix
+        >>> from sympy.utilities.misc import func_name
+        >>> func_name(Matrix.diag(1, cls=ImmutableMatrix))
+        'ImmutableDenseMatrix'
+
+        A zero dimension matrix can be used to position the start of
+        the filling at the start of an arbitrary row or column:
+
+        >>> from sympy import ones
+        >>> r2 = ones(0, 2)
+        >>> Matrix.diag(r2, 1, 2)
+        Matrix([
+        [0, 0, 1, 0],
+        [0, 0, 0, 2]])
+
+        See Also
+        ========
+        eye
+        diagonal
+        .dense.diag
+        .expressions.blockmatrix.BlockMatrix
+        .sparsetools.banded
+       """
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.matrices.dense import Matrix
+        from sympy.matrices import SparseMatrix
+        klass = kwargs.get('cls', kls)
+        if unpack and len(args) == 1 and is_sequence(args[0]) and \
+                not isinstance(args[0], MatrixBase):
+            args = args[0]
+
+        # fill a default dict with the diagonal entries
+        diag_entries = defaultdict(int)
+        rmax = cmax = 0  # keep track of the biggest index seen
+        for m in args:
+            if isinstance(m, list):
+                if strict:
+                    # if malformed, Matrix will raise an error
+                    _ = Matrix(m)
+                    r, c = _.shape
+                    m = _.tolist()
+                else:
+                    r, c, smat = SparseMatrix._handle_creation_inputs(m)
+                    for (i, j), _ in smat.items():
+                        diag_entries[(i + rmax, j + cmax)] = _
+                    m = []  # to skip process below
+            elif hasattr(m, 'shape'):  # a Matrix
+                # convert to list of lists
+                r, c = m.shape
+                m = m.tolist()
+            else:  # in this case, we're a single value
+                diag_entries[(rmax, cmax)] = m
+                rmax += 1
+                cmax += 1
+                continue
+            # process list of lists
+            for i, mi in enumerate(m):
+                for j, _ in enumerate(mi):
+                    diag_entries[(i + rmax, j + cmax)] = _
+            rmax += r
+            cmax += c
+        if rows is None:
+            rows, cols = cols, rows
+        if rows is None:
+            rows, cols = rmax, cmax
+        else:
+            cols = rows if cols is None else cols
+        if rows < rmax or cols < cmax:
+            raise ValueError(filldedent('''
+                The constructed matrix is {} x {} but a size of {} x {}
+                was specified.'''.format(rmax, cmax, rows, cols)))
+        return klass._eval_diag(rows, cols, diag_entries)
+
+    @classmethod
+    def eye(kls, rows, cols=None, **kwargs):
+        """Returns an identity matrix.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        if rows < 0 or cols < 0:
+            raise ValueError("Cannot create a {} x {} matrix. "
+                             "Both dimensions must be positive".format(rows, cols))
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_eye(rows, cols)
+
+    @classmethod
+    def jordan_block(kls, size=None, eigenvalue=None, *, band='upper', **kwargs):
+        """Returns a Jordan block
+
+        Parameters
+        ==========
+
+        size : Integer, optional
+            Specifies the shape of the Jordan block matrix.
+
+        eigenvalue : Number or Symbol
+            Specifies the value for the main diagonal of the matrix.
+
+            .. note::
+                The keyword ``eigenval`` is also specified as an alias
+                of this keyword, but it is not recommended to use.
+
+                We may deprecate the alias in later release.
+
+        band : 'upper' or 'lower', optional
+            Specifies the position of the off-diagonal to put `1` s on.
+
+        cls : Matrix, optional
+            Specifies the matrix class of the output form.
+
+            If it is not specified, the class type where the method is
+            being executed on will be returned.
+
+        Returns
+        =======
+
+        Matrix
+            A Jordan block matrix.
+
+        Raises
+        ======
+
+        ValueError
+            If insufficient arguments are given for matrix size
+            specification, or no eigenvalue is given.
+
+        Examples
+        ========
+
+        Creating a default Jordan block:
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x
+        >>> Matrix.jordan_block(4, x)
+        Matrix([
+        [x, 1, 0, 0],
+        [0, x, 1, 0],
+        [0, 0, x, 1],
+        [0, 0, 0, x]])
+
+        Creating an alternative Jordan block matrix where `1` is on
+        lower off-diagonal:
+
+        >>> Matrix.jordan_block(4, x, band='lower')
+        Matrix([
+        [x, 0, 0, 0],
+        [1, x, 0, 0],
+        [0, 1, x, 0],
+        [0, 0, 1, x]])
+
+        Creating a Jordan block with keyword arguments
+
+        >>> Matrix.jordan_block(size=4, eigenvalue=x)
+        Matrix([
+        [x, 1, 0, 0],
+        [0, x, 1, 0],
+        [0, 0, x, 1],
+        [0, 0, 0, x]])
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Jordan_matrix
+        """
+        klass = kwargs.pop('cls', kls)
+
+        eigenval = kwargs.get('eigenval', None)
+        if eigenvalue is None and eigenval is None:
+            raise ValueError("Must supply an eigenvalue")
+        elif eigenvalue != eigenval and None not in (eigenval, eigenvalue):
+            raise ValueError(
+                "Inconsistent values are given: 'eigenval'={}, "
+                "'eigenvalue'={}".format(eigenval, eigenvalue))
+        else:
+            if eigenval is not None:
+                eigenvalue = eigenval
+
+        if size is None:
+            raise ValueError("Must supply a matrix size")
+
+        size = as_int(size)
+        return klass._eval_jordan_block(size, eigenvalue, band)
+
+    @classmethod
+    def ones(kls, rows, cols=None, **kwargs):
+        """Returns a matrix of ones.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_ones(rows, cols)
+
+    @classmethod
+    def zeros(kls, rows, cols=None, **kwargs):
+        """Returns a matrix of zeros.
+
+        Parameters
+        ==========
+
+        rows : rows of the matrix
+        cols : cols of the matrix (if None, cols=rows)
+
+        kwargs
+        ======
+        cls : class of the returned matrix
+        """
+        if cols is None:
+            cols = rows
+        if rows < 0 or cols < 0:
+            raise ValueError("Cannot create a {} x {} matrix. "
+                             "Both dimensions must be positive".format(rows, cols))
+        klass = kwargs.get('cls', kls)
+        rows, cols = as_int(rows), as_int(cols)
+
+        return klass._eval_zeros(rows, cols)
+
+    @classmethod
+    def companion(kls, poly):
+        """Returns a companion matrix of a polynomial.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, Poly, Symbol, symbols
+        >>> x = Symbol('x')
+        >>> c0, c1, c2, c3, c4 = symbols('c0:5')
+        >>> p = Poly(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + x**5, x)
+        >>> Matrix.companion(p)
+        Matrix([
+        [0, 0, 0, 0, -c0],
+        [1, 0, 0, 0, -c1],
+        [0, 1, 0, 0, -c2],
+        [0, 0, 1, 0, -c3],
+        [0, 0, 0, 1, -c4]])
+        """
+        poly = kls._sympify(poly)
+        if not isinstance(poly, Poly):
+            raise ValueError("{} must be a Poly instance.".format(poly))
+        if not poly.is_monic:
+            raise ValueError("{} must be a monic polynomial.".format(poly))
+        if not poly.is_univariate:
+            raise ValueError(
+                "{} must be a univariate polynomial.".format(poly))
+
+        size = poly.degree()
+        if not size >= 1:
+            raise ValueError(
+                "{} must have degree not less than 1.".format(poly))
+
+        coeffs = poly.all_coeffs()
+        def entry(i, j):
+            if j == size - 1:
+                return -coeffs[-1 - i]
+            elif i == j + 1:
+                return kls.one
+            return kls.zero
+        return kls._new(size, size, entry)
+
+
+    @classmethod
+    def wilkinson(kls, n, **kwargs):
+        """Returns two square Wilkinson Matrix of size 2*n + 1
+        $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> wminus, wplus = Matrix.wilkinson(3)
+        >>> wminus
+        Matrix([
+        [-3,  1,  0, 0, 0, 0, 0],
+        [ 1, -2,  1, 0, 0, 0, 0],
+        [ 0,  1, -1, 1, 0, 0, 0],
+        [ 0,  0,  1, 0, 1, 0, 0],
+        [ 0,  0,  0, 1, 1, 1, 0],
+        [ 0,  0,  0, 0, 1, 2, 1],
+        [ 0,  0,  0, 0, 0, 1, 3]])
+        >>> wplus
+        Matrix([
+        [3, 1, 0, 0, 0, 0, 0],
+        [1, 2, 1, 0, 0, 0, 0],
+        [0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0],
+        [0, 0, 0, 1, 1, 1, 0],
+        [0, 0, 0, 0, 1, 2, 1],
+        [0, 0, 0, 0, 0, 1, 3]])
+
+        References
+        ==========
+
+        .. [1] https://blogs.mathworks.com/cleve/2013/04/15/wilkinsons-matrices-2/
+        .. [2] J. H. Wilkinson, The Algebraic Eigenvalue Problem, Claredon Press, Oxford, 1965, 662 pp.
+
+        """
+        klass = kwargs.get('cls', kls)
+        n = as_int(n)
+        return klass._eval_wilkinson(n)
+
+class MatrixProperties(MatrixRequired):
+    """Provides basic properties of a matrix."""
+
+    def _eval_atoms(self, *types):
+        result = set()
+        for i in self:
+            result.update(i.atoms(*types))
+        return result
+
+    def _eval_free_symbols(self):
+        return set().union(*(i.free_symbols for i in self if i))
+
+    def _eval_has(self, *patterns):
+        return any(a.has(*patterns) for a in self)
+
+    def _eval_is_anti_symmetric(self, simpfunc):
+        if not all(simpfunc(self[i, j] + self[j, i]).is_zero for i in range(self.rows) for j in range(self.cols)):
+            return False
+        return True
+
+    def _eval_is_diagonal(self):
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if i != j and self[i, j]:
+                    return False
+        return True
+
+    # _eval_is_hermitian is called by some general SymPy
+    # routines and has a different *args signature.  Make
+    # sure the names don't clash by adding `_matrix_` in name.
+    def _eval_is_matrix_hermitian(self, simpfunc):
+        mat = self._new(self.rows, self.cols, lambda i, j: simpfunc(self[i, j] - self[j, i].conjugate()))
+        return mat.is_zero_matrix
+
+    def _eval_is_Identity(self) -> FuzzyBool:
+        def dirac(i, j):
+            if i == j:
+                return 1
+            return 0
+
+        return all(self[i, j] == dirac(i, j)
+                for i in range(self.rows)
+                for j in range(self.cols))
+
+    def _eval_is_lower_hessenberg(self):
+        return all(self[i, j].is_zero
+                   for i in range(self.rows)
+                   for j in range(i + 2, self.cols))
+
+    def _eval_is_lower(self):
+        return all(self[i, j].is_zero
+                   for i in range(self.rows)
+                   for j in range(i + 1, self.cols))
+
+    def _eval_is_symbolic(self):
+        return self.has(Symbol)
+
+    def _eval_is_symmetric(self, simpfunc):
+        mat = self._new(self.rows, self.cols, lambda i, j: simpfunc(self[i, j] - self[j, i]))
+        return mat.is_zero_matrix
+
+    def _eval_is_zero_matrix(self):
+        if any(i.is_zero == False for i in self):
+            return False
+        if any(i.is_zero is None for i in self):
+            return None
+        return True
+
+    def _eval_is_upper_hessenberg(self):
+        return all(self[i, j].is_zero
+                   for i in range(2, self.rows)
+                   for j in range(min(self.cols, (i - 1))))
+
+    def _eval_values(self):
+        return [i for i in self if not i.is_zero]
+
+    def _has_positive_diagonals(self):
+        diagonal_entries = (self[i, i] for i in range(self.rows))
+        return fuzzy_and(x.is_positive for x in diagonal_entries)
+
+    def _has_nonnegative_diagonals(self):
+        diagonal_entries = (self[i, i] for i in range(self.rows))
+        return fuzzy_and(x.is_nonnegative for x in diagonal_entries)
+
+    def atoms(self, *types):
+        """Returns the atoms that form the current object.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import Matrix
+        >>> Matrix([[x]])
+        Matrix([[x]])
+        >>> _.atoms()
+        {x}
+        >>> Matrix([[x, y], [y, x]])
+        Matrix([
+        [x, y],
+        [y, x]])
+        >>> _.atoms()
+        {x, y}
+        """
+
+        types = tuple(t if isinstance(t, type) else type(t) for t in types)
+        if not types:
+            types = (Atom,)
+        return self._eval_atoms(*types)
+
+    @property
+    def free_symbols(self):
+        """Returns the free symbols within the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import Matrix
+        >>> Matrix([[x], [1]]).free_symbols
+        {x}
+        """
+        return self._eval_free_symbols()
+
+    def has(self, *patterns):
+        """Test whether any subexpression matches any of the patterns.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, SparseMatrix, Float
+        >>> from sympy.abc import x, y
+        >>> A = Matrix(((1, x), (0.2, 3)))
+        >>> B = SparseMatrix(((1, x), (0.2, 3)))
+        >>> A.has(x)
+        True
+        >>> A.has(y)
+        False
+        >>> A.has(Float)
+        True
+        >>> B.has(x)
+        True
+        >>> B.has(y)
+        False
+        >>> B.has(Float)
+        True
+        """
+        return self._eval_has(*patterns)
+
+    def is_anti_symmetric(self, simplify=True):
+        """Check if matrix M is an antisymmetric matrix,
+        that is, M is a square matrix with all M[i, j] == -M[j, i].
+
+        When ``simplify=True`` (default), the sum M[i, j] + M[j, i] is
+        simplified before testing to see if it is zero. By default,
+        the SymPy simplify function is used. To use a custom function
+        set simplify to a function that accepts a single argument which
+        returns a simplified expression. To skip simplification, set
+        simplify to False but note that although this will be faster,
+        it may induce false negatives.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, symbols
+        >>> m = Matrix(2, 2, [0, 1, -1, 0])
+        >>> m
+        Matrix([
+        [ 0, 1],
+        [-1, 0]])
+        >>> m.is_anti_symmetric()
+        True
+        >>> x, y = symbols('x y')
+        >>> m = Matrix(2, 3, [0, 0, x, -y, 0, 0])
+        >>> m
+        Matrix([
+        [ 0, 0, x],
+        [-y, 0, 0]])
+        >>> m.is_anti_symmetric()
+        False
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(3, 3, [0, x**2 + 2*x + 1, y,
+        ...                   -(x + 1)**2, 0, x*y,
+        ...                   -y, -x*y, 0])
+
+        Simplification of matrix elements is done by default so even
+        though two elements which should be equal and opposite would not
+        pass an equality test, the matrix is still reported as
+        anti-symmetric:
+
+        >>> m[0, 1] == -m[1, 0]
+        False
+        >>> m.is_anti_symmetric()
+        True
+
+        If ``simplify=False`` is used for the case when a Matrix is already
+        simplified, this will speed things up. Here, we see that without
+        simplification the matrix does not appear anti-symmetric:
+
+        >>> print(m.is_anti_symmetric(simplify=False))
+        None
+
+        But if the matrix were already expanded, then it would appear
+        anti-symmetric and simplification in the is_anti_symmetric routine
+        is not needed:
+
+        >>> m = m.expand()
+        >>> m.is_anti_symmetric(simplify=False)
+        True
+        """
+        # accept custom simplification
+        simpfunc = simplify
+        if not isfunction(simplify):
+            simpfunc = _simplify if simplify else lambda x: x
+
+        if not self.is_square:
+            return False
+        return self._eval_is_anti_symmetric(simpfunc)
+
+    def is_diagonal(self):
+        """Check if matrix is diagonal,
+        that is matrix in which the entries outside the main diagonal are all zero.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, diag
+        >>> m = Matrix(2, 2, [1, 0, 0, 2])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 2]])
+        >>> m.is_diagonal()
+        True
+
+        >>> m = Matrix(2, 2, [1, 1, 0, 2])
+        >>> m
+        Matrix([
+        [1, 1],
+        [0, 2]])
+        >>> m.is_diagonal()
+        False
+
+        >>> m = diag(1, 2, 3)
+        >>> m
+        Matrix([
+        [1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3]])
+        >>> m.is_diagonal()
+        True
+
+        See Also
+        ========
+
+        is_lower
+        is_upper
+        sympy.matrices.matrixbase.MatrixCommon.is_diagonalizable
+        diagonalize
+        """
+        return self._eval_is_diagonal()
+
+    @property
+    def is_weakly_diagonally_dominant(self):
+        r"""Tests if the matrix is row weakly diagonally dominant.
+
+        Explanation
+        ===========
+
+        A $n, n$ matrix $A$ is row weakly diagonally dominant if
+
+        .. math::
+            \left|A_{i, i}\right| \ge \sum_{j = 0, j \neq i}^{n-1}
+            \left|A_{i, j}\right| \quad {\text{for all }}
+            i \in \{ 0, ..., n-1 \}
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
+        >>> A.is_weakly_diagonally_dominant
+        True
+
+        >>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
+        >>> A.is_weakly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
+        >>> A.is_weakly_diagonally_dominant
+        True
+
+        Notes
+        =====
+
+        If you want to test whether a matrix is column diagonally
+        dominant, you can apply the test after transposing the matrix.
+        """
+        if not self.is_square:
+            return False
+
+        rows, cols = self.shape
+
+        def test_row(i):
+            summation = self.zero
+            for j in range(cols):
+                if i != j:
+                    summation += Abs(self[i, j])
+            return (Abs(self[i, i]) - summation).is_nonnegative
+
+        return fuzzy_and(test_row(i) for i in range(rows))
+
+    @property
+    def is_strongly_diagonally_dominant(self):
+        r"""Tests if the matrix is row strongly diagonally dominant.
+
+        Explanation
+        ===========
+
+        A $n, n$ matrix $A$ is row strongly diagonally dominant if
+
+        .. math::
+            \left|A_{i, i}\right| > \sum_{j = 0, j \neq i}^{n-1}
+            \left|A_{i, j}\right| \quad {\text{for all }}
+            i \in \{ 0, ..., n-1 \}
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]])
+        >>> A.is_strongly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]])
+        >>> A.is_strongly_diagonally_dominant
+        False
+
+        >>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]])
+        >>> A.is_strongly_diagonally_dominant
+        True
+
+        Notes
+        =====
+
+        If you want to test whether a matrix is column diagonally
+        dominant, you can apply the test after transposing the matrix.
+        """
+        if not self.is_square:
+            return False
+
+        rows, cols = self.shape
+
+        def test_row(i):
+            summation = self.zero
+            for j in range(cols):
+                if i != j:
+                    summation += Abs(self[i, j])
+            return (Abs(self[i, i]) - summation).is_positive
+
+        return fuzzy_and(test_row(i) for i in range(rows))
+
+    @property
+    def is_hermitian(self):
+        """Checks if the matrix is Hermitian.
+
+        In a Hermitian matrix element i,j is the complex conjugate of
+        element j,i.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy import I
+        >>> from sympy.abc import x
+        >>> a = Matrix([[1, I], [-I, 1]])
+        >>> a
+        Matrix([
+        [ 1, I],
+        [-I, 1]])
+        >>> a.is_hermitian
+        True
+        >>> a[0, 0] = 2*I
+        >>> a.is_hermitian
+        False
+        >>> a[0, 0] = x
+        >>> a.is_hermitian
+        >>> a[0, 1] = a[1, 0]*I
+        >>> a.is_hermitian
+        False
+        """
+        if not self.is_square:
+            return False
+
+        return self._eval_is_matrix_hermitian(_simplify)
+
+    @property
+    def is_Identity(self) -> FuzzyBool:
+        if not self.is_square:
+            return False
+        return self._eval_is_Identity()
+
+    @property
+    def is_lower_hessenberg(self):
+        r"""Checks if the matrix is in the lower-Hessenberg form.
+
+        The lower hessenberg matrix has zero entries
+        above the first superdiagonal.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 2, 0, 0], [5, 2, 3, 0], [3, 4, 3, 7], [5, 6, 1, 1]])
+        >>> a
+        Matrix([
+        [1, 2, 0, 0],
+        [5, 2, 3, 0],
+        [3, 4, 3, 7],
+        [5, 6, 1, 1]])
+        >>> a.is_lower_hessenberg
+        True
+
+        See Also
+        ========
+
+        is_upper_hessenberg
+        is_lower
+        """
+        return self._eval_is_lower_hessenberg()
+
+    @property
+    def is_lower(self):
+        """Check if matrix is a lower triangular matrix. True can be returned
+        even if the matrix is not square.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [1, 0, 0, 1])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 1]])
+        >>> m.is_lower
+        True
+
+        >>> m = Matrix(4, 3, [0, 0, 0, 2, 0, 0, 1, 4, 0, 6, 6, 5])
+        >>> m
+        Matrix([
+        [0, 0, 0],
+        [2, 0, 0],
+        [1, 4, 0],
+        [6, 6, 5]])
+        >>> m.is_lower
+        True
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(2, 2, [x**2 + y, y**2 + x, 0, x + y])
+        >>> m
+        Matrix([
+        [x**2 + y, x + y**2],
+        [       0,    x + y]])
+        >>> m.is_lower
+        False
+
+        See Also
+        ========
+
+        is_upper
+        is_diagonal
+        is_lower_hessenberg
+        """
+        return self._eval_is_lower()
+
+    @property
+    def is_square(self):
+        """Checks if a matrix is square.
+
+        A matrix is square if the number of rows equals the number of columns.
+        The empty matrix is square by definition, since the number of rows and
+        the number of columns are both zero.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> b = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        >>> c = Matrix([])
+        >>> a.is_square
+        False
+        >>> b.is_square
+        True
+        >>> c.is_square
+        True
+        """
+        return self.rows == self.cols
+
+    def is_symbolic(self):
+        """Checks if any elements contain Symbols.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.abc import x, y
+        >>> M = Matrix([[x, y], [1, 0]])
+        >>> M.is_symbolic()
+        True
+
+        """
+        return self._eval_is_symbolic()
+
+    def is_symmetric(self, simplify=True):
+        """Check if matrix is symmetric matrix,
+        that is square matrix and is equal to its transpose.
+
+        By default, simplifications occur before testing symmetry.
+        They can be skipped using 'simplify=False'; while speeding things a bit,
+        this may however induce false negatives.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [0, 1, 1, 2])
+        >>> m
+        Matrix([
+        [0, 1],
+        [1, 2]])
+        >>> m.is_symmetric()
+        True
+
+        >>> m = Matrix(2, 2, [0, 1, 2, 0])
+        >>> m
+        Matrix([
+        [0, 1],
+        [2, 0]])
+        >>> m.is_symmetric()
+        False
+
+        >>> m = Matrix(2, 3, [0, 0, 0, 0, 0, 0])
+        >>> m
+        Matrix([
+        [0, 0, 0],
+        [0, 0, 0]])
+        >>> m.is_symmetric()
+        False
+
+        >>> from sympy.abc import x, y
+        >>> m = Matrix(3, 3, [1, x**2 + 2*x + 1, y, (x + 1)**2, 2, 0, y, 0, 3])
+        >>> m
+        Matrix([
+        [         1, x**2 + 2*x + 1, y],
+        [(x + 1)**2,              2, 0],
+        [         y,              0, 3]])
+        >>> m.is_symmetric()
+        True
+
+        If the matrix is already simplified, you may speed-up is_symmetric()
+        test by using 'simplify=False'.
+
+        >>> bool(m.is_symmetric(simplify=False))
+        False
+        >>> m1 = m.expand()
+        >>> m1.is_symmetric(simplify=False)
+        True
+        """
+        simpfunc = simplify
+        if not isfunction(simplify):
+            simpfunc = _simplify if simplify else lambda x: x
+
+        if not self.is_square:
+            return False
+
+        return self._eval_is_symmetric(simpfunc)
+
+    @property
+    def is_upper_hessenberg(self):
+        """Checks if the matrix is the upper-Hessenberg form.
+
+        The upper hessenberg matrix has zero entries
+        below the first subdiagonal.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> a = Matrix([[1, 4, 2, 3], [3, 4, 1, 7], [0, 2, 3, 4], [0, 0, 1, 3]])
+        >>> a
+        Matrix([
+        [1, 4, 2, 3],
+        [3, 4, 1, 7],
+        [0, 2, 3, 4],
+        [0, 0, 1, 3]])
+        >>> a.is_upper_hessenberg
+        True
+
+        See Also
+        ========
+
+        is_lower_hessenberg
+        is_upper
+        """
+        return self._eval_is_upper_hessenberg()
+
+    @property
+    def is_upper(self):
+        """Check if matrix is an upper triangular matrix. True can be returned
+        even if the matrix is not square.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, [1, 0, 0, 1])
+        >>> m
+        Matrix([
+        [1, 0],
+        [0, 1]])
+        >>> m.is_upper
+        True
+
+        >>> m = Matrix(4, 3, [5, 1, 9, 0, 4, 6, 0, 0, 5, 0, 0, 0])
+        >>> m
+        Matrix([
+        [5, 1, 9],
+        [0, 4, 6],
+        [0, 0, 5],
+        [0, 0, 0]])
+        >>> m.is_upper
+        True
+
+        >>> m = Matrix(2, 3, [4, 2, 5, 6, 1, 1])
+        >>> m
+        Matrix([
+        [4, 2, 5],
+        [6, 1, 1]])
+        >>> m.is_upper
+        False
+
+        See Also
+        ========
+
+        is_lower
+        is_diagonal
+        is_upper_hessenberg
+        """
+        return all(self[i, j].is_zero
+                   for i in range(1, self.rows)
+                   for j in range(min(i, self.cols)))
+
+    @property
+    def is_zero_matrix(self):
+        """Checks if a matrix is a zero matrix.
+
+        A matrix is zero if every element is zero.  A matrix need not be square
+        to be considered zero.  The empty matrix is zero by the principle of
+        vacuous truth.  For a matrix that may or may not be zero (e.g.
+        contains a symbol), this will be None
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, zeros
+        >>> from sympy.abc import x
+        >>> a = Matrix([[0, 0], [0, 0]])
+        >>> b = zeros(3, 4)
+        >>> c = Matrix([[0, 1], [0, 0]])
+        >>> d = Matrix([])
+        >>> e = Matrix([[x, 0], [0, 0]])
+        >>> a.is_zero_matrix
+        True
+        >>> b.is_zero_matrix
+        True
+        >>> c.is_zero_matrix
+        False
+        >>> d.is_zero_matrix
+        True
+        >>> e.is_zero_matrix
+        """
+        return self._eval_is_zero_matrix()
+
+    def values(self):
+        """Return non-zero values of self."""
+        return self._eval_values()
+
+
+class MatrixOperations(MatrixRequired):
+    """Provides basic matrix shape and elementwise
+    operations.  Should not be instantiated directly."""
+
+    def _eval_adjoint(self):
+        return self.transpose().conjugate()
+
+    def _eval_applyfunc(self, f):
+        out = self._new(self.rows, self.cols, [f(x) for x in self])
+        return out
+
+    def _eval_as_real_imag(self):  # type: ignore
+        return (self.applyfunc(re), self.applyfunc(im))
+
+    def _eval_conjugate(self):
+        return self.applyfunc(lambda x: x.conjugate())
+
+    def _eval_permute_cols(self, perm):
+        # apply the permutation to a list
+        mapping = list(perm)
+
+        def entry(i, j):
+            return self[i, mapping[j]]
+
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_permute_rows(self, perm):
+        # apply the permutation to a list
+        mapping = list(perm)
+
+        def entry(i, j):
+            return self[mapping[i], j]
+
+        return self._new(self.rows, self.cols, entry)
+
+    def _eval_trace(self):
+        return sum(self[i, i] for i in range(self.rows))
+
+    def _eval_transpose(self):
+        return self._new(self.cols, self.rows, lambda i, j: self[j, i])
+
+    def adjoint(self):
+        """Conjugate transpose or Hermitian conjugation."""
+        return self._eval_adjoint()
+
+    def applyfunc(self, f):
+        """Apply a function to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> m = Matrix(2, 2, lambda i, j: i*2+j)
+        >>> m
+        Matrix([
+        [0, 1],
+        [2, 3]])
+        >>> m.applyfunc(lambda i: 2*i)
+        Matrix([
+        [0, 2],
+        [4, 6]])
+
+        """
+        if not callable(f):
+            raise TypeError("`f` must be callable.")
+
+        return self._eval_applyfunc(f)
+
+    def as_real_imag(self, deep=True, **hints):
+        """Returns a tuple containing the (real, imaginary) part of matrix."""
+        # XXX: Ignoring deep and hints...
+        return self._eval_as_real_imag()
+
+    def conjugate(self):
+        """Return the by-element conjugation.
+
+        Examples
+        ========
+
+        >>> from sympy import SparseMatrix, I
+        >>> a = SparseMatrix(((1, 2 + I), (3, 4), (I, -I)))
+        >>> a
+        Matrix([
+        [1, 2 + I],
+        [3,     4],
+        [I,    -I]])
+        >>> a.C
+        Matrix([
+        [ 1, 2 - I],
+        [ 3,     4],
+        [-I,     I]])
+
+        See Also
+        ========
+
+        transpose: Matrix transposition
+        H: Hermite conjugation
+        sympy.matrices.matrixbase.MatrixBase.D: Dirac conjugation
+        """
+        return self._eval_conjugate()
+
+    def doit(self, **hints):
+        return self.applyfunc(lambda x: x.doit(**hints))
+
+    def evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False):
+        """Apply evalf() to each element of self."""
+        options = {'subs':subs, 'maxn':maxn, 'chop':chop, 'strict':strict,
+                'quad':quad, 'verbose':verbose}
+        return self.applyfunc(lambda i: i.evalf(n, **options))
+
+    def expand(self, deep=True, modulus=None, power_base=True, power_exp=True,
+               mul=True, log=True, multinomial=True, basic=True, **hints):
+        """Apply core.function.expand to each entry of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import Matrix
+        >>> Matrix(1, 1, [x*(x+1)])
+        Matrix([[x*(x + 1)]])
+        >>> _.expand()
+        Matrix([[x**2 + x]])
+
+        """
+        return self.applyfunc(lambda x: x.expand(
+            deep, modulus, power_base, power_exp, mul, log, multinomial, basic,
+            **hints))
+
+    @property
+    def H(self):
+        """Return Hermite conjugate.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, I
+        >>> m = Matrix((0, 1 + I, 2, 3))
+        >>> m
+        Matrix([
+        [    0],
+        [1 + I],
+        [    2],
+        [    3]])
+        >>> m.H
+        Matrix([[0, 1 - I, 2, 3]])
+
+        See Also
+        ========
+
+        conjugate: By-element conjugation
+        sympy.matrices.matrixbase.MatrixBase.D: Dirac conjugation
+        """
+        return self.T.C
+
+    def permute(self, perm, orientation='rows', direction='forward'):
+        r"""Permute the rows or columns of a matrix by the given list of
+        swaps.
+
+        Parameters
+        ==========
+
+        perm : Permutation, list, or list of lists
+            A representation for the permutation.
+
+            If it is ``Permutation``, it is used directly with some
+            resizing with respect to the matrix size.
+
+            If it is specified as list of lists,
+            (e.g., ``[[0, 1], [0, 2]]``), then the permutation is formed
+            from applying the product of cycles. The direction how the
+            cyclic product is applied is described in below.
+
+            If it is specified as a list, the list should represent
+            an array form of a permutation. (e.g., ``[1, 2, 0]``) which
+            would would form the swapping function
+            `0 \mapsto 1, 1 \mapsto 2, 2\mapsto 0`.
+
+        orientation : 'rows', 'cols'
+            A flag to control whether to permute the rows or the columns
+
+        direction : 'forward', 'backward'
+            A flag to control whether to apply the permutations from
+            the start of the list first, or from the back of the list
+            first.
+
+            For example, if the permutation specification is
+            ``[[0, 1], [0, 2]]``,
+
+            If the flag is set to ``'forward'``, the cycle would be
+            formed as `0 \mapsto 2, 2 \mapsto 1, 1 \mapsto 0`.
+
+            If the flag is set to ``'backward'``, the cycle would be
+            formed as `0 \mapsto 1, 1 \mapsto 2, 2 \mapsto 0`.
+
+            If the argument ``perm`` is not in a form of list of lists,
+            this flag takes no effect.
+
+        Examples
+        ========
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='forward')
+        Matrix([
+        [0, 0, 1],
+        [1, 0, 0],
+        [0, 1, 0]])
+
+        >>> from sympy import eye
+        >>> M = eye(3)
+        >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='backward')
+        Matrix([
+        [0, 1, 0],
+        [0, 0, 1],
+        [1, 0, 0]])
+
+        Notes
+        =====
+
+        If a bijective function
+        `\sigma : \mathbb{N}_0 \rightarrow \mathbb{N}_0` denotes the
+        permutation.
+
+        If the matrix `A` is the matrix to permute, represented as
+        a horizontal or a vertical stack of vectors:
+
+        .. math::
+            A =
+            \begin{bmatrix}
+            a_0 \\ a_1 \\ \vdots \\ a_{n-1}
+            \end{bmatrix} =
+            \begin{bmatrix}
+            \alpha_0 & \alpha_1 & \cdots & \alpha_{n-1}
+            \end{bmatrix}
+
+        If the matrix `B` is the result, the permutation of matrix rows
+        is defined as:
+
+        .. math::
+            B := \begin{bmatrix}
+            a_{\sigma(0)} \\ a_{\sigma(1)} \\ \vdots \\ a_{\sigma(n-1)}
+            \end{bmatrix}
+
+        And the permutation of matrix columns is defined as:
+
+        .. math::
+            B := \begin{bmatrix}
+            \alpha_{\sigma(0)} & \alpha_{\sigma(1)} &
+            \cdots & \alpha_{\sigma(n-1)}
+            \end{bmatrix}
+        """
+        from sympy.combinatorics import Permutation
+
+        # allow british variants and `columns`
+        if direction == 'forwards':
+            direction = 'forward'
+        if direction == 'backwards':
+            direction = 'backward'
+        if orientation == 'columns':
+            orientation = 'cols'
+
+        if direction not in ('forward', 'backward'):
+            raise TypeError("direction='{}' is an invalid kwarg. "
+                            "Try 'forward' or 'backward'".format(direction))
+        if orientation not in ('rows', 'cols'):
+            raise TypeError("orientation='{}' is an invalid kwarg. "
+                            "Try 'rows' or 'cols'".format(orientation))
+
+        if not isinstance(perm, (Permutation, Iterable)):
+            raise ValueError(
+                "{} must be a list, a list of lists, "
+                "or a SymPy permutation object.".format(perm))
+
+        # ensure all swaps are in range
+        max_index = self.rows if orientation == 'rows' else self.cols
+        if not all(0 <= t <= max_index for t in flatten(list(perm))):
+            raise IndexError("`swap` indices out of range.")
+
+        if perm and not isinstance(perm, Permutation) and \
+            isinstance(perm[0], Iterable):
+            if direction == 'forward':
+                perm = list(reversed(perm))
+            perm = Permutation(perm, size=max_index+1)
+        else:
+            perm = Permutation(perm, size=max_index+1)
+
+        if orientation == 'rows':
+            return self._eval_permute_rows(perm)
+        if orientation == 'cols':
+            return self._eval_permute_cols(perm)
+
+    def permute_cols(self, swaps, direction='forward'):
+        """Alias for
+        ``self.permute(swaps, orientation='cols', direction=direction)``
+
+        See Also
+        ========
+
+        permute
+        """
+        return self.permute(swaps, orientation='cols', direction=direction)
+
+    def permute_rows(self, swaps, direction='forward'):
+        """Alias for
+        ``self.permute(swaps, orientation='rows', direction=direction)``
+
+        See Also
+        ========
+
+        permute
+        """
+        return self.permute(swaps, orientation='rows', direction=direction)
+
+    def refine(self, assumptions=True):
+        """Apply refine to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Matrix, Abs, sqrt, Q
+        >>> x = Symbol('x')
+        >>> Matrix([[Abs(x)**2, sqrt(x**2)],[sqrt(x**2), Abs(x)**2]])
+        Matrix([
+        [ Abs(x)**2, sqrt(x**2)],
+        [sqrt(x**2),  Abs(x)**2]])
+        >>> _.refine(Q.real(x))
+        Matrix([
+        [  x**2, Abs(x)],
+        [Abs(x),   x**2]])
+
+        """
+        return self.applyfunc(lambda x: refine(x, assumptions))
+
+    def replace(self, F, G, map=False, simultaneous=True, exact=None):
+        """Replaces Function F in Matrix entries with Function G.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Function, Matrix
+        >>> F, G = symbols('F, G', cls=Function)
+        >>> M = Matrix(2, 2, lambda i, j: F(i+j)) ; M
+        Matrix([
+        [F(0), F(1)],
+        [F(1), F(2)]])
+        >>> N = M.replace(F,G)
+        >>> N
+        Matrix([
+        [G(0), G(1)],
+        [G(1), G(2)]])
+        """
+        return self.applyfunc(
+            lambda x: x.replace(F, G, map=map, simultaneous=simultaneous, exact=exact))
+
+    def rot90(self, k=1):
+        """Rotates Matrix by 90 degrees
+
+        Parameters
+        ==========
+
+        k : int
+            Specifies how many times the matrix is rotated by 90 degrees
+            (clockwise when positive, counter-clockwise when negative).
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, symbols
+        >>> A = Matrix(2, 2, symbols('a:d'))
+        >>> A
+        Matrix([
+        [a, b],
+        [c, d]])
+
+        Rotating the matrix clockwise one time:
+
+        >>> A.rot90(1)
+        Matrix([
+        [c, a],
+        [d, b]])
+
+        Rotating the matrix anticlockwise two times:
+
+        >>> A.rot90(-2)
+        Matrix([
+        [d, c],
+        [b, a]])
+        """
+
+        mod = k%4
+        if mod == 0:
+            return self
+        if mod == 1:
+            return self[::-1, ::].T
+        if mod == 2:
+            return self[::-1, ::-1]
+        if mod == 3:
+            return self[::, ::-1].T
+
+    def simplify(self, **kwargs):
+        """Apply simplify to each element of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, sin, cos
+        >>> SparseMatrix(1, 1, [x*sin(y)**2 + x*cos(y)**2])
+        Matrix([[x*sin(y)**2 + x*cos(y)**2]])
+        >>> _.simplify()
+        Matrix([[x]])
+        """
+        return self.applyfunc(lambda x: x.simplify(**kwargs))
+
+    def subs(self, *args, **kwargs):  # should mirror core.basic.subs
+        """Return a new matrix with subs applied to each entry.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, Matrix
+        >>> SparseMatrix(1, 1, [x])
+        Matrix([[x]])
+        >>> _.subs(x, y)
+        Matrix([[y]])
+        >>> Matrix(_).subs(y, x)
+        Matrix([[x]])
+        """
+
+        if len(args) == 1 and  not isinstance(args[0], (dict, set)) and iter(args[0]) and not is_sequence(args[0]):
+            args = (list(args[0]),)
+
+        return self.applyfunc(lambda x: x.subs(*args, **kwargs))
+
+    def trace(self):
+        """
+        Returns the trace of a square matrix i.e. the sum of the
+        diagonal elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix(2, 2, [1, 2, 3, 4])
+        >>> A.trace()
+        5
+
+        """
+        if self.rows != self.cols:
+            raise NonSquareMatrixError()
+        return self._eval_trace()
+
+    def transpose(self):
+        """
+        Returns the transpose of the matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix(2, 2, [1, 2, 3, 4])
+        >>> A.transpose()
+        Matrix([
+        [1, 3],
+        [2, 4]])
+
+        >>> from sympy import Matrix, I
+        >>> m=Matrix(((1, 2+I), (3, 4)))
+        >>> m
+        Matrix([
+        [1, 2 + I],
+        [3,     4]])
+        >>> m.transpose()
+        Matrix([
+        [    1, 3],
+        [2 + I, 4]])
+        >>> m.T == m.transpose()
+        True
+
+        See Also
+        ========
+
+        conjugate: By-element conjugation
+
+        """
+        return self._eval_transpose()
+
+    @property
+    def T(self):
+        '''Matrix transposition'''
+        return self.transpose()
+
+    @property
+    def C(self):
+        '''By-element conjugation'''
+        return self.conjugate()
+
+    def n(self, *args, **kwargs):
+        """Apply evalf() to each element of self."""
+        return self.evalf(*args, **kwargs)
+
+    def xreplace(self, rule):  # should mirror core.basic.xreplace
+        """Return a new matrix with xreplace applied to each entry.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import SparseMatrix, Matrix
+        >>> SparseMatrix(1, 1, [x])
+        Matrix([[x]])
+        >>> _.xreplace({x: y})
+        Matrix([[y]])
+        >>> Matrix(_).xreplace({y: x})
+        Matrix([[x]])
+        """
+        return self.applyfunc(lambda x: x.xreplace(rule))
+
+    def _eval_simplify(self, **kwargs):
+        # XXX: We can't use self.simplify here as mutable subclasses will
+        # override simplify and have it return None
+        return MatrixOperations.simplify(self, **kwargs)
+
+    def _eval_trigsimp(self, **opts):
+        from sympy.simplify.trigsimp import trigsimp
+        return self.applyfunc(lambda x: trigsimp(x, **opts))
+
+    def upper_triangular(self, k=0):
+        """Return the elements on and above the kth diagonal of a matrix.
+        If k is not specified then simply returns upper-triangular portion
+        of a matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ones
+        >>> A = ones(4)
+        >>> A.upper_triangular()
+        Matrix([
+        [1, 1, 1, 1],
+        [0, 1, 1, 1],
+        [0, 0, 1, 1],
+        [0, 0, 0, 1]])
+
+        >>> A.upper_triangular(2)
+        Matrix([
+        [0, 0, 1, 1],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0],
+        [0, 0, 0, 0]])
+
+        >>> A.upper_triangular(-1)
+        Matrix([
+        [1, 1, 1, 1],
+        [1, 1, 1, 1],
+        [0, 1, 1, 1],
+        [0, 0, 1, 1]])
+
+        """
+
+        def entry(i, j):
+            return self[i, j] if i + k <= j else self.zero
+
+        return self._new(self.rows, self.cols, entry)
+
+
+    def lower_triangular(self, k=0):
+        """Return the elements on and below the kth diagonal of a matrix.
+        If k is not specified then simply returns lower-triangular portion
+        of a matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ones
+        >>> A = ones(4)
+        >>> A.lower_triangular()
+        Matrix([
+        [1, 0, 0, 0],
+        [1, 1, 0, 0],
+        [1, 1, 1, 0],
+        [1, 1, 1, 1]])
+
+        >>> A.lower_triangular(-2)
+        Matrix([
+        [0, 0, 0, 0],
+        [0, 0, 0, 0],
+        [1, 0, 0, 0],
+        [1, 1, 0, 0]])
+
+        >>> A.lower_triangular(1)
+        Matrix([
+        [1, 1, 0, 0],
+        [1, 1, 1, 0],
+        [1, 1, 1, 1],
+        [1, 1, 1, 1]])
+
+        """
+
+        def entry(i, j):
+            return self[i, j] if i + k >= j else self.zero
+
+        return self._new(self.rows, self.cols, entry)
+
+
+
+class MatrixArithmetic(MatrixRequired):
+    """Provides basic matrix arithmetic operations.
+    Should not be instantiated directly."""
+
+    _op_priority = 10.01
+
+    def _eval_Abs(self):
+        return self._new(self.rows, self.cols, lambda i, j: Abs(self[i, j]))
+
+    def _eval_add(self, other):
+        return self._new(self.rows, self.cols,
+                         lambda i, j: self[i, j] + other[i, j])
+
+    def _eval_matrix_mul(self, other):
+        def entry(i, j):
+            vec = [self[i,k]*other[k,j] for k in range(self.cols)]
+            try:
+                return Add(*vec)
+            except (TypeError, SympifyError):
+                # Some matrices don't work with `sum` or `Add`
+                # They don't work with `sum` because `sum` tries to add `0`
+                # Fall back to a safe way to multiply if the `Add` fails.
+                return reduce(lambda a, b: a + b, vec)
+
+        return self._new(self.rows, other.cols, entry)
+
+    def _eval_matrix_mul_elementwise(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: self[i,j]*other[i,j])
+
+    def _eval_matrix_rmul(self, other):
+        def entry(i, j):
+            return sum(other[i,k]*self[k,j] for k in range(other.cols))
+        return self._new(other.rows, self.cols, entry)
+
+    def _eval_pow_by_recursion(self, num):
+        if num == 1:
+            return self
+
+        if num % 2 == 1:
+            a, b = self, self._eval_pow_by_recursion(num - 1)
+        else:
+            a = b = self._eval_pow_by_recursion(num // 2)
+
+        return a.multiply(b)
+
+    def _eval_pow_by_cayley(self, exp):
+        from sympy.discrete.recurrences import linrec_coeffs
+        row = self.shape[0]
+        p = self.charpoly()
+
+        coeffs = (-p).all_coeffs()[1:]
+        coeffs = linrec_coeffs(coeffs, exp)
+        new_mat = self.eye(row)
+        ans = self.zeros(row)
+
+        for i in range(row):
+            ans += coeffs[i]*new_mat
+            new_mat *= self
+
+        return ans
+
+    def _eval_pow_by_recursion_dotprodsimp(self, num, prevsimp=None):
+        if prevsimp is None:
+            prevsimp = [True]*len(self)
+
+        if num == 1:
+            return self
+
+        if num % 2 == 1:
+            a, b = self, self._eval_pow_by_recursion_dotprodsimp(num - 1,
+                    prevsimp=prevsimp)
+        else:
+            a = b = self._eval_pow_by_recursion_dotprodsimp(num // 2,
+                    prevsimp=prevsimp)
+
+        m     = a.multiply(b, dotprodsimp=False)
+        lenm  = len(m)
+        elems = [None]*lenm
+
+        for i in range(lenm):
+            if prevsimp[i]:
+                elems[i], prevsimp[i] = _dotprodsimp(m[i], withsimp=True)
+            else:
+                elems[i] = m[i]
+
+        return m._new(m.rows, m.cols, elems)
+
+    def _eval_scalar_mul(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: self[i,j]*other)
+
+    def _eval_scalar_rmul(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: other*self[i,j])
+
+    def _eval_Mod(self, other):
+        return self._new(self.rows, self.cols, lambda i, j: Mod(self[i, j], other))
+
+    # Python arithmetic functions
+    def __abs__(self):
+        """Returns a new matrix with entry-wise absolute values."""
+        return self._eval_Abs()
+
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        """Return self + other, raising ShapeError if shapes do not match."""
+        if isinstance(other, NDimArray): # Matrix and array addition is currently not implemented
+            return NotImplemented
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check.
+        if hasattr(other, 'shape'):
+            if self.shape != other.shape:
+                raise ShapeError("Matrix size mismatch: %s + %s" % (
+                    self.shape, other.shape))
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            # call the highest-priority class's _eval_add
+            a, b = self, other
+            if a.__class__ != classof(a, b):
+                b, a = a, b
+            return a._eval_add(b)
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_add(self, other)
+
+        raise TypeError('cannot add %s and %s' % (type(self), type(other)))
+
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other):
+        return self * (self.one / other)
+
+    @call_highest_priority('__rmatmul__')
+    def __matmul__(self, other):
+        other = _matrixify(other)
+        if not getattr(other, 'is_Matrix', False) and not getattr(other, 'is_MatrixLike', False):
+            return NotImplemented
+
+        return self.__mul__(other)
+
+    def __mod__(self, other):
+        return self.applyfunc(lambda x: x % other)
+
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other):
+        """Return self*other where other is either a scalar or a matrix
+        of compatible dimensions.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> 2*A == A*2 == Matrix([[2, 4, 6], [8, 10, 12]])
+        True
+        >>> B = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        >>> A*B
+        Matrix([
+        [30, 36, 42],
+        [66, 81, 96]])
+        >>> B*A
+        Traceback (most recent call last):
+        ...
+        ShapeError: Matrices size mismatch.
+        >>>
+
+        See Also
+        ========
+
+        matrix_multiply_elementwise
+        """
+
+        return self.multiply(other)
+
+    def multiply(self, other, dotprodsimp=None):
+        """Same as __mul__() but with optional simplification.
+
+        Parameters
+        ==========
+
+        dotprodsimp : bool, optional
+            Specifies whether intermediate term algebraic simplification is used
+            during matrix multiplications to control expression blowup and thus
+            speed up calculation. Default is off.
+        """
+
+        isimpbool = _get_intermediate_simp_bool(False, dotprodsimp)
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check. Double check other is not explicitly not a Matrix.
+        if (hasattr(other, 'shape') and len(other.shape) == 2 and
+            (getattr(other, 'is_Matrix', True) or
+             getattr(other, 'is_MatrixLike', True))):
+            if self.shape[1] != other.shape[0]:
+                raise ShapeError("Matrix size mismatch: %s * %s." % (
+                    self.shape, other.shape))
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            m = self._eval_matrix_mul(other)
+            if isimpbool:
+                return m._new(m.rows, m.cols, [_dotprodsimp(e) for e in m])
+            return m
+
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_matrix_mul(self, other)
+
+        # if 'other' is not iterable then scalar multiplication.
+        if not isinstance(other, Iterable):
+            try:
+                return self._eval_scalar_mul(other)
+            except TypeError:
+                pass
+
+        return NotImplemented
+
+    def multiply_elementwise(self, other):
+        """Return the Hadamard product (elementwise product) of A and B
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> A = Matrix([[0, 1, 2], [3, 4, 5]])
+        >>> B = Matrix([[1, 10, 100], [100, 10, 1]])
+        >>> A.multiply_elementwise(B)
+        Matrix([
+        [  0, 10, 200],
+        [300, 40,   5]])
+
+        See Also
+        ========
+
+        sympy.matrices.matrixbase.MatrixBase.cross
+        sympy.matrices.matrixbase.MatrixBase.dot
+        multiply
+        """
+        if self.shape != other.shape:
+            raise ShapeError("Matrix shapes must agree {} != {}".format(self.shape, other.shape))
+
+        return self._eval_matrix_mul_elementwise(other)
+
+    def __neg__(self):
+        return self._eval_scalar_mul(-1)
+
+    @call_highest_priority('__rpow__')
+    def __pow__(self, exp):
+        """Return self**exp a scalar or symbol."""
+
+        return self.pow(exp)
+
+
+    def pow(self, exp, method=None):
+        r"""Return self**exp a scalar or symbol.
+
+        Parameters
+        ==========
+
+        method : multiply, mulsimp, jordan, cayley
+            If multiply then it returns exponentiation using recursion.
+            If jordan then Jordan form exponentiation will be used.
+            If cayley then the exponentiation is done using Cayley-Hamilton
+            theorem.
+            If mulsimp then the exponentiation is done using recursion
+            with dotprodsimp. This specifies whether intermediate term
+            algebraic simplification is used during naive matrix power to
+            control expression blowup and thus speed up calculation.
+            If None, then it heuristically decides which method to use.
+
+        """
+
+        if method is not None and method not in ['multiply', 'mulsimp', 'jordan', 'cayley']:
+            raise TypeError('No such method')
+        if self.rows != self.cols:
+            raise NonSquareMatrixError()
+        a = self
+        jordan_pow = getattr(a, '_matrix_pow_by_jordan_blocks', None)
+        exp = sympify(exp)
+
+        if exp.is_zero:
+            return a._new(a.rows, a.cols, lambda i, j: int(i == j))
+        if exp == 1:
+            return a
+
+        diagonal = getattr(a, 'is_diagonal', None)
+        if diagonal is not None and diagonal():
+            return a._new(a.rows, a.cols, lambda i, j: a[i,j]**exp if i == j else 0)
+
+        if exp.is_Number and exp % 1 == 0:
+            if a.rows == 1:
+                return a._new([[a[0]**exp]])
+            if exp < 0:
+                exp = -exp
+                a = a.inv()
+        # When certain conditions are met,
+        # Jordan block algorithm is faster than
+        # computation by recursion.
+        if method == 'jordan':
+            try:
+                return jordan_pow(exp)
+            except MatrixError:
+                if method == 'jordan':
+                    raise
+
+        elif method == 'cayley':
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("cayley method is only valid for integer powers")
+            return a._eval_pow_by_cayley(exp)
+
+        elif method == "mulsimp":
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("mulsimp method is only valid for integer powers")
+            return a._eval_pow_by_recursion_dotprodsimp(exp)
+
+        elif method == "multiply":
+            if not exp.is_Number or exp % 1 != 0:
+                raise ValueError("multiply method is only valid for integer powers")
+            return a._eval_pow_by_recursion(exp)
+
+        elif method is None and exp.is_Number and exp % 1 == 0:
+            if exp.is_Float:
+                exp = Integer(exp)
+            # Decide heuristically which method to apply
+            if a.rows == 2 and exp > 100000:
+                return jordan_pow(exp)
+            elif _get_intermediate_simp_bool(True, None):
+                return a._eval_pow_by_recursion_dotprodsimp(exp)
+            elif exp > 10000:
+                return a._eval_pow_by_cayley(exp)
+            else:
+                return a._eval_pow_by_recursion(exp)
+
+        if jordan_pow:
+            try:
+                return jordan_pow(exp)
+            except NonInvertibleMatrixError:
+                # Raised by jordan_pow on zero determinant matrix unless exp is
+                # definitely known to be a non-negative integer.
+                # Here we raise if n is definitely not a non-negative integer
+                # but otherwise we can leave this as an unevaluated MatPow.
+                if exp.is_integer is False or exp.is_nonnegative is False:
+                    raise
+
+        from sympy.matrices.expressions import MatPow
+        return MatPow(a, exp)
+
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        return self + other
+
+    @call_highest_priority('__matmul__')
+    def __rmatmul__(self, other):
+        other = _matrixify(other)
+        if not getattr(other, 'is_Matrix', False) and not getattr(other, 'is_MatrixLike', False):
+            return NotImplemented
+
+        return self.__rmul__(other)
+
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other):
+        return self.rmultiply(other)
+
+    def rmultiply(self, other, dotprodsimp=None):
+        """Same as __rmul__() but with optional simplification.
+
+        Parameters
+        ==========
+
+        dotprodsimp : bool, optional
+            Specifies whether intermediate term algebraic simplification is used
+            during matrix multiplications to control expression blowup and thus
+            speed up calculation. Default is off.
+        """
+        isimpbool = _get_intermediate_simp_bool(False, dotprodsimp)
+        other = _matrixify(other)
+        # matrix-like objects can have shapes.  This is
+        # our first sanity check. Double check other is not explicitly not a Matrix.
+        if (hasattr(other, 'shape') and len(other.shape) == 2 and
+            (getattr(other, 'is_Matrix', True) or
+             getattr(other, 'is_MatrixLike', True))):
+            if self.shape[0] != other.shape[1]:
+                raise ShapeError("Matrix size mismatch.")
+
+        # honest SymPy matrices defer to their class's routine
+        if getattr(other, 'is_Matrix', False):
+            m = self._eval_matrix_rmul(other)
+            if isimpbool:
+                return m._new(m.rows, m.cols, [_dotprodsimp(e) for e in m])
+            return m
+        # Matrix-like objects can be passed to CommonMatrix routines directly.
+        if getattr(other, 'is_MatrixLike', False):
+            return MatrixArithmetic._eval_matrix_rmul(self, other)
+
+        # if 'other' is not iterable then scalar multiplication.
+        if not isinstance(other, Iterable):
+            try:
+                return self._eval_scalar_rmul(other)
+            except TypeError:
+                pass
+
+        return NotImplemented
+
+    @call_highest_priority('__sub__')
+    def __rsub__(self, a):
+        return (-self) + a
+
+    @call_highest_priority('__rsub__')
+    def __sub__(self, a):
+        return self + (-a)
+
+
+class MatrixCommon(MatrixArithmetic, MatrixOperations, MatrixProperties,
+                  MatrixSpecial, MatrixShaping):
+    """All common matrix operations including basic arithmetic, shaping,
+    and special matrices like `zeros`, and `eye`."""
+    _diff_wrt = True  # type: bool
+
+
+class _MinimalMatrix:
+    """Class providing the minimum functionality
+    for a matrix-like object and implementing every method
+    required for a `MatrixRequired`.  This class does not have everything
+    needed to become a full-fledged SymPy object, but it will satisfy the
+    requirements of anything inheriting from `MatrixRequired`.  If you wish
+    to make a specialized matrix type, make sure to implement these
+    methods and properties with the exception of `__init__` and `__repr__`
+    which are included for convenience."""
+
+    is_MatrixLike = True
+    _sympify = staticmethod(sympify)
+    _class_priority = 3
+    zero = S.Zero
+    one = S.One
+
+    is_Matrix = True
+    is_MatrixExpr = False
+
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    def __init__(self, rows, cols=None, mat=None, copy=False):
+        if isfunction(mat):
+            # if we passed in a function, use that to populate the indices
+            mat = [mat(i, j) for i in range(rows) for j in range(cols)]
+        if cols is None and mat is None:
+            mat = rows
+        rows, cols = getattr(mat, 'shape', (rows, cols))
+        try:
+            # if we passed in a list of lists, flatten it and set the size
+            if cols is None and mat is None:
+                mat = rows
+            cols = len(mat[0])
+            rows = len(mat)
+            mat = [x for l in mat for x in l]
+        except (IndexError, TypeError):
+            pass
+        self.mat = tuple(self._sympify(x) for x in mat)
+        self.rows, self.cols = rows, cols
+        if self.rows is None or self.cols is None:
+            raise NotImplementedError("Cannot initialize matrix with given parameters")
+
+    def __getitem__(self, key):
+        def _normalize_slices(row_slice, col_slice):
+            """Ensure that row_slice and col_slice do not have
+            `None` in their arguments.  Any integers are converted
+            to slices of length 1"""
+            if not isinstance(row_slice, slice):
+                row_slice = slice(row_slice, row_slice + 1, None)
+            row_slice = slice(*row_slice.indices(self.rows))
+
+            if not isinstance(col_slice, slice):
+                col_slice = slice(col_slice, col_slice + 1, None)
+            col_slice = slice(*col_slice.indices(self.cols))
+
+            return (row_slice, col_slice)
+
+        def _coord_to_index(i, j):
+            """Return the index in _mat corresponding
+            to the (i,j) position in the matrix. """
+            return i * self.cols + j
+
+        if isinstance(key, tuple):
+            i, j = key
+            if isinstance(i, slice) or isinstance(j, slice):
+                # if the coordinates are not slices, make them so
+                # and expand the slices so they don't contain `None`
+                i, j = _normalize_slices(i, j)
+
+                rowsList, colsList = list(range(self.rows))[i], \
+                                     list(range(self.cols))[j]
+                indices = (i * self.cols + j for i in rowsList for j in
+                           colsList)
+                return self._new(len(rowsList), len(colsList),
+                                 [self.mat[i] for i in indices])
+
+            # if the key is a tuple of ints, change
+            # it to an array index
+            key = _coord_to_index(i, j)
+        return self.mat[key]
+
+    def __eq__(self, other):
+        try:
+            classof(self, other)
+        except TypeError:
+            return False
+        return (
+            self.shape == other.shape and list(self) == list(other))
+
+    def __len__(self):
+        return self.rows*self.cols
+
+    def __repr__(self):
+        return "_MinimalMatrix({}, {}, {})".format(self.rows, self.cols,
+                                                   self.mat)
+
+    @property
+    def shape(self):
+        return (self.rows, self.cols)
+
+
+class _CastableMatrix: # this is needed here ONLY FOR TESTS.
+    def as_mutable(self):
+        return self
+
+    def as_immutable(self):
+        return self
+
+
+class _MatrixWrapper:
+    """Wrapper class providing the minimum functionality for a matrix-like
+    object: .rows, .cols, .shape, indexability, and iterability. CommonMatrix
+    math operations should work on matrix-like objects. This one is intended for
+    matrix-like objects which use the same indexing format as SymPy with respect
+    to returning matrix elements instead of rows for non-tuple indexes.
+    """
+
+    is_Matrix     = False # needs to be here because of __getattr__
+    is_MatrixLike = True
+
+    def __init__(self, mat, shape):
+        self.mat = mat
+        self.shape = shape
+        self.rows, self.cols = shape
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            return sympify(self.mat.__getitem__(key))
+
+        return sympify(self.mat.__getitem__((key // self.rows, key % self.cols)))
+
+    def __iter__(self): # supports numpy.matrix and numpy.array
+        mat = self.mat
+        cols = self.cols
+
+        return iter(sympify(mat[r, c]) for r in range(self.rows) for c in range(cols))
+
+
+def _matrixify(mat):
+    """If `mat` is a Matrix or is matrix-like,
+    return a Matrix or MatrixWrapper object.  Otherwise
+    `mat` is passed through without modification."""
+
+    if getattr(mat, 'is_Matrix', False) or getattr(mat, 'is_MatrixLike', False):
+        return mat
+
+    if not(getattr(mat, 'is_Matrix', True) or getattr(mat, 'is_MatrixLike', True)):
+        return mat
+
+    shape = None
+
+    if hasattr(mat, 'shape'): # numpy, scipy.sparse
+        if len(mat.shape) == 2:
+            shape = mat.shape
+    elif hasattr(mat, 'rows') and hasattr(mat, 'cols'): # mpmath
+        shape = (mat.rows, mat.cols)
+
+    if shape:
+        return _MatrixWrapper(mat, shape)
+
+    return mat
+
+
+def a2idx(j, n=None):
+    """Return integer after making positive and validating against n."""
+    if not isinstance(j, int):
+        jindex = getattr(j, '__index__', None)
+        if jindex is not None:
+            j = jindex()
+        else:
+            raise IndexError("Invalid index a[%r]" % (j,))
+    if n is not None:
+        if j < 0:
+            j += n
+        if not (j >= 0 and j < n):
+            raise IndexError("Index out of range: a[%s]" % (j,))
+    return int(j)
+
+
+def classof(A, B):
+    """
+    Get the type of the result when combining matrices of different types.
+
+    Currently the strategy is that immutability is contagious.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, ImmutableMatrix
+    >>> from sympy.matrices.matrixbase import classof
+    >>> M = Matrix([[1, 2], [3, 4]]) # a Mutable Matrix
+    >>> IM = ImmutableMatrix([[1, 2], [3, 4]])
+    >>> classof(M, IM)
+    <class 'sympy.matrices.immutable.ImmutableDenseMatrix'>
+    """
+    priority_A = getattr(A, '_class_priority', None)
+    priority_B = getattr(B, '_class_priority', None)
+    if None not in (priority_A, priority_B):
+        if A._class_priority > B._class_priority:
+            return A.__class__
+        else:
+            return B.__class__
+
+    try:
+        import numpy
+    except ImportError:
+        pass
+    else:
+        if isinstance(A, numpy.ndarray):
+            return B.__class__
+        if isinstance(B, numpy.ndarray):
+            return A.__class__
+
+    raise TypeError("Incompatible classes %s, %s" % (A.__class__, B.__class__))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/decompositions.py

@@ -0,0 +1,1621 @@
+import copy
+
+from sympy.core import S
+from sympy.core.function import expand_mul
+from sympy.functions.elementary.miscellaneous import Min, sqrt
+from sympy.functions.elementary.complexes import sign
+
+from .exceptions import NonSquareMatrixError, NonPositiveDefiniteMatrixError
+from .utilities import _get_intermediate_simp, _iszero
+from .determinant import _find_reasonable_pivot_naive
+
+
+def _rank_decomposition(M, iszerofunc=_iszero, simplify=False):
+    r"""Returns a pair of matrices (`C`, `F`) with matching rank
+    such that `A = C F`.
+
+    Parameters
+    ==========
+
+    iszerofunc : Function, optional
+        A function used for detecting whether an element can
+        act as a pivot.  ``lambda x: x.is_zero`` is used by default.
+
+    simplify : Bool or Function, optional
+        A function used to simplify elements when looking for a
+        pivot. By default SymPy's ``simplify`` is used.
+
+    Returns
+    =======
+
+    (C, F) : Matrices
+        `C` and `F` are full-rank matrices with rank as same as `A`,
+        whose product gives `A`.
+
+        See Notes for additional mathematical details.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([
+    ...     [1, 3, 1, 4],
+    ...     [2, 7, 3, 9],
+    ...     [1, 5, 3, 1],
+    ...     [1, 2, 0, 8]
+    ... ])
+    >>> C, F = A.rank_decomposition()
+    >>> C
+    Matrix([
+    [1, 3, 4],
+    [2, 7, 9],
+    [1, 5, 1],
+    [1, 2, 8]])
+    >>> F
+    Matrix([
+    [1, 0, -2, 0],
+    [0, 1,  1, 0],
+    [0, 0,  0, 1]])
+    >>> C * F == A
+    True
+
+    Notes
+    =====
+
+    Obtaining `F`, an RREF of `A`, is equivalent to creating a
+    product
+
+    .. math::
+        E_n E_{n-1} ... E_1 A = F
+
+    where `E_n, E_{n-1}, \dots, E_1` are the elimination matrices or
+    permutation matrices equivalent to each row-reduction step.
+
+    The inverse of the same product of elimination matrices gives
+    `C`:
+
+    .. math::
+        C = \left(E_n E_{n-1} \dots E_1\right)^{-1}
+
+    It is not necessary, however, to actually compute the inverse:
+    the columns of `C` are those from the original matrix with the
+    same column indices as the indices of the pivot columns of `F`.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Rank_factorization
+
+    .. [2] Piziak, R.; Odell, P. L. (1 June 1999).
+        "Full Rank Factorization of Matrices".
+        Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.rref
+    """
+
+    F, pivot_cols = M.rref(simplify=simplify, iszerofunc=iszerofunc,
+            pivots=True)
+    rank = len(pivot_cols)
+
+    C = M.extract(range(M.rows), pivot_cols)
+    F = F[:rank, :]
+
+    return C, F
+
+
+def _liupc(M):
+    """Liu's algorithm, for pre-determination of the Elimination Tree of
+    the given matrix, used in row-based symbolic Cholesky factorization.
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix
+    >>> S = SparseMatrix([
+    ... [1, 0, 3, 2],
+    ... [0, 0, 1, 0],
+    ... [4, 0, 0, 5],
+    ... [0, 6, 7, 0]])
+    >>> S.liupc()
+    ([[0], [], [0], [1, 2]], [4, 3, 4, 4])
+
+    References
+    ==========
+
+    .. [1] Symbolic Sparse Cholesky Factorization using Elimination Trees,
+           Jeroen Van Grondelle (1999)
+           https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582
+    """
+    # Algorithm 2.4, p 17 of reference
+
+    # get the indices of the elements that are non-zero on or below diag
+    R = [[] for r in range(M.rows)]
+
+    for r, c, _ in M.row_list():
+        if c <= r:
+            R[r].append(c)
+
+    inf     = len(R)  # nothing will be this large
+    parent  = [inf]*M.rows
+    virtual = [inf]*M.rows
+
+    for r in range(M.rows):
+        for c in R[r][:-1]:
+            while virtual[c] < r:
+                t          = virtual[c]
+                virtual[c] = r
+                c          = t
+
+            if virtual[c] == inf:
+                parent[c] = virtual[c] = r
+
+    return R, parent
+
+def _row_structure_symbolic_cholesky(M):
+    """Symbolic cholesky factorization, for pre-determination of the
+    non-zero structure of the Cholesky factororization.
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix
+    >>> S = SparseMatrix([
+    ... [1, 0, 3, 2],
+    ... [0, 0, 1, 0],
+    ... [4, 0, 0, 5],
+    ... [0, 6, 7, 0]])
+    >>> S.row_structure_symbolic_cholesky()
+    [[0], [], [0], [1, 2]]
+
+    References
+    ==========
+
+    .. [1] Symbolic Sparse Cholesky Factorization using Elimination Trees,
+           Jeroen Van Grondelle (1999)
+           https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582
+    """
+
+    R, parent = M.liupc()
+    inf       = len(R)  # this acts as infinity
+    Lrow      = copy.deepcopy(R)
+
+    for k in range(M.rows):
+        for j in R[k]:
+            while j != inf and j != k:
+                Lrow[k].append(j)
+                j = parent[j]
+
+        Lrow[k] = sorted(set(Lrow[k]))
+
+    return Lrow
+
+
+def _cholesky(M, hermitian=True):
+    """Returns the Cholesky-type decomposition L of a matrix A
+    such that L * L.H == A if hermitian flag is True,
+    or L * L.T == A if hermitian is False.
+
+    A must be a Hermitian positive-definite matrix if hermitian is True,
+    or a symmetric matrix if it is False.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
+    >>> A.cholesky()
+    Matrix([
+    [ 5, 0, 0],
+    [ 3, 3, 0],
+    [-1, 1, 3]])
+    >>> A.cholesky() * A.cholesky().T
+    Matrix([
+    [25, 15, -5],
+    [15, 18,  0],
+    [-5,  0, 11]])
+
+    The matrix can have complex entries:
+
+    >>> from sympy import I
+    >>> A = Matrix(((9, 3*I), (-3*I, 5)))
+    >>> A.cholesky()
+    Matrix([
+    [ 3, 0],
+    [-I, 2]])
+    >>> A.cholesky() * A.cholesky().H
+    Matrix([
+    [   9, 3*I],
+    [-3*I,   5]])
+
+    Non-hermitian Cholesky-type decomposition may be useful when the
+    matrix is not positive-definite.
+
+    >>> A = Matrix([[1, 2], [2, 1]])
+    >>> L = A.cholesky(hermitian=False)
+    >>> L
+    Matrix([
+    [1,         0],
+    [2, sqrt(3)*I]])
+    >>> L*L.T == A
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.LDLdecomposition
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    QRdecomposition
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if hermitian and not M.is_hermitian:
+        raise ValueError("Matrix must be Hermitian.")
+    if not hermitian and not M.is_symmetric():
+        raise ValueError("Matrix must be symmetric.")
+
+    L   = MutableDenseMatrix.zeros(M.rows, M.rows)
+
+    if hermitian:
+        for i in range(M.rows):
+            for j in range(i):
+                L[i, j] = ((1 / L[j, j])*(M[i, j] -
+                    sum(L[i, k]*L[j, k].conjugate() for k in range(j))))
+
+            Lii2 = (M[i, i] -
+                sum(L[i, k]*L[i, k].conjugate() for k in range(i)))
+
+            if Lii2.is_positive is False:
+                raise NonPositiveDefiniteMatrixError(
+                    "Matrix must be positive-definite")
+
+            L[i, i] = sqrt(Lii2)
+
+    else:
+        for i in range(M.rows):
+            for j in range(i):
+                L[i, j] = ((1 / L[j, j])*(M[i, j] -
+                    sum(L[i, k]*L[j, k] for k in range(j))))
+
+            L[i, i] = sqrt(M[i, i] -
+                sum(L[i, k]**2 for k in range(i)))
+
+    return M._new(L)
+
+def _cholesky_sparse(M, hermitian=True):
+    """
+    Returns the Cholesky decomposition L of a matrix A
+    such that L * L.T = A
+
+    A must be a square, symmetric, positive-definite
+    and non-singular matrix
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix
+    >>> A = SparseMatrix(((25,15,-5),(15,18,0),(-5,0,11)))
+    >>> A.cholesky()
+    Matrix([
+    [ 5, 0, 0],
+    [ 3, 3, 0],
+    [-1, 1, 3]])
+    >>> A.cholesky() * A.cholesky().T == A
+    True
+
+    The matrix can have complex entries:
+
+    >>> from sympy import I
+    >>> A = SparseMatrix(((9, 3*I), (-3*I, 5)))
+    >>> A.cholesky()
+    Matrix([
+    [ 3, 0],
+    [-I, 2]])
+    >>> A.cholesky() * A.cholesky().H
+    Matrix([
+    [   9, 3*I],
+    [-3*I,   5]])
+
+    Non-hermitian Cholesky-type decomposition may be useful when the
+    matrix is not positive-definite.
+
+    >>> A = SparseMatrix([[1, 2], [2, 1]])
+    >>> L = A.cholesky(hermitian=False)
+    >>> L
+    Matrix([
+    [1,         0],
+    [2, sqrt(3)*I]])
+    >>> L*L.T == A
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.sparse.SparseMatrix.LDLdecomposition
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    QRdecomposition
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if hermitian and not M.is_hermitian:
+        raise ValueError("Matrix must be Hermitian.")
+    if not hermitian and not M.is_symmetric():
+        raise ValueError("Matrix must be symmetric.")
+
+    dps       = _get_intermediate_simp(expand_mul, expand_mul)
+    Crowstruc = M.row_structure_symbolic_cholesky()
+    C         = MutableDenseMatrix.zeros(M.rows)
+
+    for i in range(len(Crowstruc)):
+        for j in Crowstruc[i]:
+            if i != j:
+                C[i, j] = M[i, j]
+                summ    = 0
+
+                for p1 in Crowstruc[i]:
+                    if p1 < j:
+                        for p2 in Crowstruc[j]:
+                            if p2 < j:
+                                if p1 == p2:
+                                    if hermitian:
+                                        summ += C[i, p1]*C[j, p1].conjugate()
+                                    else:
+                                        summ += C[i, p1]*C[j, p1]
+                            else:
+                                break
+                        else:
+                            break
+
+                C[i, j] = dps((C[i, j] - summ) / C[j, j])
+
+            else: # i == j
+                C[j, j] = M[j, j]
+                summ    = 0
+
+                for k in Crowstruc[j]:
+                    if k < j:
+                        if hermitian:
+                            summ += C[j, k]*C[j, k].conjugate()
+                        else:
+                            summ += C[j, k]**2
+                    else:
+                        break
+
+                Cjj2 = dps(C[j, j] - summ)
+
+                if hermitian and Cjj2.is_positive is False:
+                    raise NonPositiveDefiniteMatrixError(
+                        "Matrix must be positive-definite")
+
+                C[j, j] = sqrt(Cjj2)
+
+    return M._new(C)
+
+
+def _LDLdecomposition(M, hermitian=True):
+    """Returns the LDL Decomposition (L, D) of matrix A,
+    such that L * D * L.H == A if hermitian flag is True, or
+    L * D * L.T == A if hermitian is False.
+    This method eliminates the use of square root.
+    Further this ensures that all the diagonal entries of L are 1.
+    A must be a Hermitian positive-definite matrix if hermitian is True,
+    or a symmetric matrix otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, eye
+    >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
+    >>> L, D = A.LDLdecomposition()
+    >>> L
+    Matrix([
+    [   1,   0, 0],
+    [ 3/5,   1, 0],
+    [-1/5, 1/3, 1]])
+    >>> D
+    Matrix([
+    [25, 0, 0],
+    [ 0, 9, 0],
+    [ 0, 0, 9]])
+    >>> L * D * L.T * A.inv() == eye(A.rows)
+    True
+
+    The matrix can have complex entries:
+
+    >>> from sympy import I
+    >>> A = Matrix(((9, 3*I), (-3*I, 5)))
+    >>> L, D = A.LDLdecomposition()
+    >>> L
+    Matrix([
+    [   1, 0],
+    [-I/3, 1]])
+    >>> D
+    Matrix([
+    [9, 0],
+    [0, 4]])
+    >>> L*D*L.H == A
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.cholesky
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    QRdecomposition
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if hermitian and not M.is_hermitian:
+        raise ValueError("Matrix must be Hermitian.")
+    if not hermitian and not M.is_symmetric():
+        raise ValueError("Matrix must be symmetric.")
+
+    D   = MutableDenseMatrix.zeros(M.rows, M.rows)
+    L   = MutableDenseMatrix.eye(M.rows)
+
+    if hermitian:
+        for i in range(M.rows):
+            for j in range(i):
+                L[i, j] = (1 / D[j, j])*(M[i, j] - sum(
+                    L[i, k]*L[j, k].conjugate()*D[k, k] for k in range(j)))
+
+            D[i, i] = (M[i, i] -
+                sum(L[i, k]*L[i, k].conjugate()*D[k, k] for k in range(i)))
+
+            if D[i, i].is_positive is False:
+                raise NonPositiveDefiniteMatrixError(
+                    "Matrix must be positive-definite")
+
+    else:
+        for i in range(M.rows):
+            for j in range(i):
+                L[i, j] = (1 / D[j, j])*(M[i, j] - sum(
+                    L[i, k]*L[j, k]*D[k, k] for k in range(j)))
+
+            D[i, i] = M[i, i] - sum(L[i, k]**2*D[k, k] for k in range(i))
+
+    return M._new(L), M._new(D)
+
+def _LDLdecomposition_sparse(M, hermitian=True):
+    """
+    Returns the LDL Decomposition (matrices ``L`` and ``D``) of matrix
+    ``A``, such that ``L * D * L.T == A``. ``A`` must be a square,
+    symmetric, positive-definite and non-singular.
+
+    This method eliminates the use of square root and ensures that all
+    the diagonal entries of L are 1.
+
+    Examples
+    ========
+
+    >>> from sympy import SparseMatrix
+    >>> A = SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))
+    >>> L, D = A.LDLdecomposition()
+    >>> L
+    Matrix([
+    [   1,   0, 0],
+    [ 3/5,   1, 0],
+    [-1/5, 1/3, 1]])
+    >>> D
+    Matrix([
+    [25, 0, 0],
+    [ 0, 9, 0],
+    [ 0, 0, 9]])
+    >>> L * D * L.T == A
+    True
+
+    """
+
+    from .dense import MutableDenseMatrix
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+    if hermitian and not M.is_hermitian:
+        raise ValueError("Matrix must be Hermitian.")
+    if not hermitian and not M.is_symmetric():
+        raise ValueError("Matrix must be symmetric.")
+
+    dps       = _get_intermediate_simp(expand_mul, expand_mul)
+    Lrowstruc = M.row_structure_symbolic_cholesky()
+    L         = MutableDenseMatrix.eye(M.rows)
+    D         = MutableDenseMatrix.zeros(M.rows, M.cols)
+
+    for i in range(len(Lrowstruc)):
+        for j in Lrowstruc[i]:
+            if i != j:
+                L[i, j] = M[i, j]
+                summ    = 0
+
+                for p1 in Lrowstruc[i]:
+                    if p1 < j:
+                        for p2 in Lrowstruc[j]:
+                            if p2 < j:
+                                if p1 == p2:
+                                    if hermitian:
+                                        summ += L[i, p1]*L[j, p1].conjugate()*D[p1, p1]
+                                    else:
+                                        summ += L[i, p1]*L[j, p1]*D[p1, p1]
+                            else:
+                                break
+                    else:
+                        break
+
+                L[i, j] = dps((L[i, j] - summ) / D[j, j])
+
+            else: # i == j
+                D[i, i] = M[i, i]
+                summ    = 0
+
+                for k in Lrowstruc[i]:
+                    if k < i:
+                        if hermitian:
+                            summ += L[i, k]*L[i, k].conjugate()*D[k, k]
+                        else:
+                            summ += L[i, k]**2*D[k, k]
+                    else:
+                        break
+
+                D[i, i] = dps(D[i, i] - summ)
+
+                if hermitian and D[i, i].is_positive is False:
+                    raise NonPositiveDefiniteMatrixError(
+                        "Matrix must be positive-definite")
+
+    return M._new(L), M._new(D)
+
+
+def _LUdecomposition(M, iszerofunc=_iszero, simpfunc=None, rankcheck=False):
+    """Returns (L, U, perm) where L is a lower triangular matrix with unit
+    diagonal, U is an upper triangular matrix, and perm is a list of row
+    swap index pairs. If A is the original matrix, then
+    ``A = (L*U).permuteBkwd(perm)``, and the row permutation matrix P such
+    that $P A = L U$ can be computed by ``P = eye(A.rows).permuteFwd(perm)``.
+
+    See documentation for LUCombined for details about the keyword argument
+    rankcheck, iszerofunc, and simpfunc.
+
+    Parameters
+    ==========
+
+    rankcheck : bool, optional
+        Determines if this function should detect the rank
+        deficiency of the matrixis and should raise a
+        ``ValueError``.
+
+    iszerofunc : function, optional
+        A function which determines if a given expression is zero.
+
+        The function should be a callable that takes a single
+        SymPy expression and returns a 3-valued boolean value
+        ``True``, ``False``, or ``None``.
+
+        It is internally used by the pivot searching algorithm.
+        See the notes section for a more information about the
+        pivot searching algorithm.
+
+    simpfunc : function or None, optional
+        A function that simplifies the input.
+
+        If this is specified as a function, this function should be
+        a callable that takes a single SymPy expression and returns
+        an another SymPy expression that is algebraically
+        equivalent.
+
+        If ``None``, it indicates that the pivot search algorithm
+        should not attempt to simplify any candidate pivots.
+
+        It is internally used by the pivot searching algorithm.
+        See the notes section for a more information about the
+        pivot searching algorithm.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> a = Matrix([[4, 3], [6, 3]])
+    >>> L, U, _ = a.LUdecomposition()
+    >>> L
+    Matrix([
+    [  1, 0],
+    [3/2, 1]])
+    >>> U
+    Matrix([
+    [4,    3],
+    [0, -3/2]])
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.cholesky
+    sympy.matrices.dense.DenseMatrix.LDLdecomposition
+    QRdecomposition
+    LUdecomposition_Simple
+    LUdecompositionFF
+    LUsolve
+    """
+
+    combined, p = M.LUdecomposition_Simple(iszerofunc=iszerofunc,
+        simpfunc=simpfunc, rankcheck=rankcheck)
+
+    # L is lower triangular ``M.rows x M.rows``
+    # U is upper triangular ``M.rows x M.cols``
+    # L has unit diagonal. For each column in combined, the subcolumn
+    # below the diagonal of combined is shared by L.
+    # If L has more columns than combined, then the remaining subcolumns
+    # below the diagonal of L are zero.
+    # The upper triangular portion of L and combined are equal.
+    def entry_L(i, j):
+        if i < j:
+            # Super diagonal entry
+            return M.zero
+        elif i == j:
+            return M.one
+        elif j < combined.cols:
+            return combined[i, j]
+
+        # Subdiagonal entry of L with no corresponding
+        # entry in combined
+        return M.zero
+
+    def entry_U(i, j):
+        return M.zero if i > j else combined[i, j]
+
+    L = M._new(combined.rows, combined.rows, entry_L)
+    U = M._new(combined.rows, combined.cols, entry_U)
+
+    return L, U, p
+
+def _LUdecomposition_Simple(M, iszerofunc=_iszero, simpfunc=None,
+        rankcheck=False):
+    r"""Compute the PLU decomposition of the matrix.
+
+    Parameters
+    ==========
+
+    rankcheck : bool, optional
+        Determines if this function should detect the rank
+        deficiency of the matrixis and should raise a
+        ``ValueError``.
+
+    iszerofunc : function, optional
+        A function which determines if a given expression is zero.
+
+        The function should be a callable that takes a single
+        SymPy expression and returns a 3-valued boolean value
+        ``True``, ``False``, or ``None``.
+
+        It is internally used by the pivot searching algorithm.
+        See the notes section for a more information about the
+        pivot searching algorithm.
+
+    simpfunc : function or None, optional
+        A function that simplifies the input.
+
+        If this is specified as a function, this function should be
+        a callable that takes a single SymPy expression and returns
+        an another SymPy expression that is algebraically
+        equivalent.
+
+        If ``None``, it indicates that the pivot search algorithm
+        should not attempt to simplify any candidate pivots.
+
+        It is internally used by the pivot searching algorithm.
+        See the notes section for a more information about the
+        pivot searching algorithm.
+
+    Returns
+    =======
+
+    (lu, row_swaps) : (Matrix, list)
+        If the original matrix is a $m, n$ matrix:
+
+        *lu* is a $m, n$ matrix, which contains result of the
+        decomposition in a compressed form. See the notes section
+        to see how the matrix is compressed.
+
+        *row_swaps* is a $m$-element list where each element is a
+        pair of row exchange indices.
+
+        ``A = (L*U).permute_backward(perm)``, and the row
+        permutation matrix $P$ from the formula $P A = L U$ can be
+        computed by ``P=eye(A.row).permute_forward(perm)``.
+
+    Raises
+    ======
+
+    ValueError
+        Raised if ``rankcheck=True`` and the matrix is found to
+        be rank deficient during the computation.
+
+    Notes
+    =====
+
+    About the PLU decomposition:
+
+    PLU decomposition is a generalization of a LU decomposition
+    which can be extended for rank-deficient matrices.
+
+    It can further be generalized for non-square matrices, and this
+    is the notation that SymPy is using.
+
+    PLU decomposition is a decomposition of a $m, n$ matrix $A$ in
+    the form of $P A = L U$ where
+
+    * $L$ is a $m, m$ lower triangular matrix with unit diagonal
+        entries.
+    * $U$ is a $m, n$ upper triangular matrix.
+    * $P$ is a $m, m$ permutation matrix.
+
+    So, for a square matrix, the decomposition would look like:
+
+    .. math::
+        L = \begin{bmatrix}
+        1 & 0 & 0 & \cdots & 0 \\
+        L_{1, 0} & 1 & 0 & \cdots & 0 \\
+        L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & 1
+        \end{bmatrix}
+
+    .. math::
+        U = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\
+        0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\
+        0 & 0 & U_{2, 2} & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        0 & 0 & 0 & \cdots & U_{n-1, n-1}
+        \end{bmatrix}
+
+    And for a matrix with more rows than the columns,
+    the decomposition would look like:
+
+    .. math::
+        L = \begin{bmatrix}
+        1 & 0 & 0 & \cdots & 0 & 0 & \cdots & 0 \\
+        L_{1, 0} & 1 & 0 & \cdots & 0 & 0 & \cdots & 0 \\
+        L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 & 0 & \cdots & 0 \\
+        \vdots & \vdots & \vdots & \ddots & \vdots & \vdots & \ddots
+        & \vdots \\
+        L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & 1 & 0
+        & \cdots & 0 \\
+        L_{n, 0} & L_{n, 1} & L_{n, 2} & \cdots & L_{n, n-1} & 1
+        & \cdots & 0 \\
+        \vdots & \vdots & \vdots & \ddots & \vdots & \vdots
+        & \ddots & \vdots \\
+        L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & L_{m-1, n-1}
+        & 0 & \cdots & 1 \\
+        \end{bmatrix}
+
+    .. math::
+        U = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\
+        0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\
+        0 & 0 & U_{2, 2} & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        0 & 0 & 0 & \cdots & U_{n-1, n-1} \\
+        0 & 0 & 0 & \cdots & 0 \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        0 & 0 & 0 & \cdots & 0
+        \end{bmatrix}
+
+    Finally, for a matrix with more columns than the rows, the
+    decomposition would look like:
+
+    .. math::
+        L = \begin{bmatrix}
+        1 & 0 & 0 & \cdots & 0 \\
+        L_{1, 0} & 1 & 0 & \cdots & 0 \\
+        L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & 1
+        \end{bmatrix}
+
+    .. math::
+        U = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, m-1}
+        & \cdots & U_{0, n-1} \\
+        0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, m-1}
+        & \cdots & U_{1, n-1} \\
+        0 & 0 & U_{2, 2} & \cdots & U_{2, m-1}
+        & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots
+        & \cdots & \vdots \\
+        0 & 0 & 0 & \cdots & U_{m-1, m-1}
+        & \cdots & U_{m-1, n-1} \\
+        \end{bmatrix}
+
+    About the compressed LU storage:
+
+    The results of the decomposition are often stored in compressed
+    forms rather than returning $L$ and $U$ matrices individually.
+
+    It may be less intiuitive, but it is commonly used for a lot of
+    numeric libraries because of the efficiency.
+
+    The storage matrix is defined as following for this specific
+    method:
+
+    * The subdiagonal elements of $L$ are stored in the subdiagonal
+        portion of $LU$, that is $LU_{i, j} = L_{i, j}$ whenever
+        $i > j$.
+    * The elements on the diagonal of $L$ are all 1, and are not
+        explicitly stored.
+    * $U$ is stored in the upper triangular portion of $LU$, that is
+        $LU_{i, j} = U_{i, j}$ whenever $i <= j$.
+    * For a case of $m > n$, the right side of the $L$ matrix is
+        trivial to store.
+    * For a case of $m < n$, the below side of the $U$ matrix is
+        trivial to store.
+
+    So, for a square matrix, the compressed output matrix would be:
+
+    .. math::
+        LU = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\
+        L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\
+        L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & U_{n-1, n-1}
+        \end{bmatrix}
+
+    For a matrix with more rows than the columns, the compressed
+    output matrix would be:
+
+    .. math::
+        LU = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\
+        L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\
+        L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots
+        & U_{n-1, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots \\
+        L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots
+        & L_{m-1, n-1} \\
+        \end{bmatrix}
+
+    For a matrix with more columns than the rows, the compressed
+    output matrix would be:
+
+    .. math::
+        LU = \begin{bmatrix}
+        U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, m-1}
+        & \cdots & U_{0, n-1} \\
+        L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, m-1}
+        & \cdots & U_{1, n-1} \\
+        L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, m-1}
+        & \cdots & U_{2, n-1} \\
+        \vdots & \vdots & \vdots & \ddots & \vdots
+        & \cdots & \vdots \\
+        L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & U_{m-1, m-1}
+        & \cdots & U_{m-1, n-1} \\
+        \end{bmatrix}
+
+    About the pivot searching algorithm:
+
+    When a matrix contains symbolic entries, the pivot search algorithm
+    differs from the case where every entry can be categorized as zero or
+    nonzero.
+    The algorithm searches column by column through the submatrix whose
+    top left entry coincides with the pivot position.
+    If it exists, the pivot is the first entry in the current search
+    column that iszerofunc guarantees is nonzero.
+    If no such candidate exists, then each candidate pivot is simplified
+    if simpfunc is not None.
+    The search is repeated, with the difference that a candidate may be
+    the pivot if ``iszerofunc()`` cannot guarantee that it is nonzero.
+    In the second search the pivot is the first candidate that
+    iszerofunc can guarantee is nonzero.
+    If no such candidate exists, then the pivot is the first candidate
+    for which iszerofunc returns None.
+    If no such candidate exists, then the search is repeated in the next
+    column to the right.
+    The pivot search algorithm differs from the one in ``rref()``, which
+    relies on ``_find_reasonable_pivot()``.
+    Future versions of ``LUdecomposition_simple()`` may use
+    ``_find_reasonable_pivot()``.
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    LUdecompositionFF
+    LUsolve
+    """
+
+    if rankcheck:
+        # https://github.com/sympy/sympy/issues/9796
+        pass
+
+    if S.Zero in M.shape:
+        # Define LU decomposition of a matrix with no entries as a matrix
+        # of the same dimensions with all zero entries.
+        return M.zeros(M.rows, M.cols), []
+
+    dps       = _get_intermediate_simp()
+    lu        = M.as_mutable()
+    row_swaps = []
+
+    pivot_col = 0
+
+    for pivot_row in range(0, lu.rows - 1):
+        # Search for pivot. Prefer entry that iszeropivot determines
+        # is nonzero, over entry that iszeropivot cannot guarantee
+        # is  zero.
+        # XXX ``_find_reasonable_pivot`` uses slow zero testing. Blocked by bug #10279
+        # Future versions of LUdecomposition_simple can pass iszerofunc and simpfunc
+        # to _find_reasonable_pivot().
+        # In pass 3 of _find_reasonable_pivot(), the predicate in ``if x.equals(S.Zero):``
+        # calls sympy.simplify(), and not the simplification function passed in via
+        # the keyword argument simpfunc.
+        iszeropivot = True
+
+        while pivot_col != M.cols and iszeropivot:
+            sub_col = (lu[r, pivot_col] for r in range(pivot_row, M.rows))
+
+            pivot_row_offset, pivot_value, is_assumed_non_zero, ind_simplified_pairs =\
+                _find_reasonable_pivot_naive(sub_col, iszerofunc, simpfunc)
+
+            iszeropivot = pivot_value is None
+
+            if iszeropivot:
+                # All candidate pivots in this column are zero.
+                # Proceed to next column.
+                pivot_col += 1
+
+        if rankcheck and pivot_col != pivot_row:
+            # All entries including and below the pivot position are
+            # zero, which indicates that the rank of the matrix is
+            # strictly less than min(num rows, num cols)
+            # Mimic behavior of previous implementation, by throwing a
+            # ValueError.
+            raise ValueError("Rank of matrix is strictly less than"
+                                " number of rows or columns."
+                                " Pass keyword argument"
+                                " rankcheck=False to compute"
+                                " the LU decomposition of this matrix.")
+
+        candidate_pivot_row = None if pivot_row_offset is None else pivot_row + pivot_row_offset
+
+        if candidate_pivot_row is None and iszeropivot:
+            # If candidate_pivot_row is None and iszeropivot is True
+            # after pivot search has completed, then the submatrix
+            # below and to the right of (pivot_row, pivot_col) is
+            # all zeros, indicating that Gaussian elimination is
+            # complete.
+            return lu, row_swaps
+
+        # Update entries simplified during pivot search.
+        for offset, val in ind_simplified_pairs:
+            lu[pivot_row + offset, pivot_col] = val
+
+        if pivot_row != candidate_pivot_row:
+            # Row swap book keeping:
+            # Record which rows were swapped.
+            # Update stored portion of L factor by multiplying L on the
+            # left and right with the current permutation.
+            # Swap rows of U.
+            row_swaps.append([pivot_row, candidate_pivot_row])
+
+            # Update L.
+            lu[pivot_row, 0:pivot_row], lu[candidate_pivot_row, 0:pivot_row] = \
+                lu[candidate_pivot_row, 0:pivot_row], lu[pivot_row, 0:pivot_row]
+
+            # Swap pivot row of U with candidate pivot row.
+            lu[pivot_row, pivot_col:lu.cols], lu[candidate_pivot_row, pivot_col:lu.cols] = \
+                lu[candidate_pivot_row, pivot_col:lu.cols], lu[pivot_row, pivot_col:lu.cols]
+
+        # Introduce zeros below the pivot by adding a multiple of the
+        # pivot row to a row under it, and store the result in the
+        # row under it.
+        # Only entries in the target row whose index is greater than
+        # start_col may be nonzero.
+        start_col = pivot_col + 1
+
+        for row in range(pivot_row + 1, lu.rows):
+            # Store factors of L in the subcolumn below
+            # (pivot_row, pivot_row).
+            lu[row, pivot_row] = \
+                dps(lu[row, pivot_col]/lu[pivot_row, pivot_col])
+
+            # Form the linear combination of the pivot row and the current
+            # row below the pivot row that zeros the entries below the pivot.
+            # Employing slicing instead of a loop here raises
+            # NotImplementedError: Cannot add Zero to MutableSparseMatrix
+            # in sympy/matrices/tests/test_sparse.py.
+            # c = pivot_row + 1 if pivot_row == pivot_col else pivot_col
+            for c in range(start_col, lu.cols):
+                lu[row, c] = dps(lu[row, c] - lu[row, pivot_row]*lu[pivot_row, c])
+
+        if pivot_row != pivot_col:
+            # matrix rank < min(num rows, num cols),
+            # so factors of L are not stored directly below the pivot.
+            # These entries are zero by construction, so don't bother
+            # computing them.
+            for row in range(pivot_row + 1, lu.rows):
+                lu[row, pivot_col] = M.zero
+
+        pivot_col += 1
+
+        if pivot_col == lu.cols:
+            # All candidate pivots are zero implies that Gaussian
+            # elimination is complete.
+            return lu, row_swaps
+
+    if rankcheck:
+        if iszerofunc(
+                lu[Min(lu.rows, lu.cols) - 1, Min(lu.rows, lu.cols) - 1]):
+            raise ValueError("Rank of matrix is strictly less than"
+                                " number of rows or columns."
+                                " Pass keyword argument"
+                                " rankcheck=False to compute"
+                                " the LU decomposition of this matrix.")
+
+    return lu, row_swaps
+
+def _LUdecompositionFF(M):
+    """Compute a fraction-free LU decomposition.
+
+    Returns 4 matrices P, L, D, U such that PA = L D**-1 U.
+    If the elements of the matrix belong to some integral domain I, then all
+    elements of L, D and U are guaranteed to belong to I.
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    LUdecomposition_Simple
+    LUsolve
+
+    References
+    ==========
+
+    .. [1] W. Zhou & D.J. Jeffrey, "Fraction-free matrix factors: new forms
+        for LU and QR factors". Frontiers in Computer Science in China,
+        Vol 2, no. 1, pp. 67-80, 2008.
+    """
+
+    from sympy.matrices import SparseMatrix
+
+    zeros    = SparseMatrix.zeros
+    eye      = SparseMatrix.eye
+    n, m     = M.rows, M.cols
+    U, L, P  = M.as_mutable(), eye(n), eye(n)
+    DD       = zeros(n, n)
+    oldpivot = 1
+
+    for k in range(n - 1):
+        if U[k, k] == 0:
+            for kpivot in range(k + 1, n):
+                if U[kpivot, k]:
+                    break
+            else:
+                raise ValueError("Matrix is not full rank")
+
+            U[k, k:], U[kpivot, k:] = U[kpivot, k:], U[k, k:]
+            L[k, :k], L[kpivot, :k] = L[kpivot, :k], L[k, :k]
+            P[k, :], P[kpivot, :]   = P[kpivot, :], P[k, :]
+
+        L [k, k] = Ukk = U[k, k]
+        DD[k, k] = oldpivot * Ukk
+
+        for i in range(k + 1, n):
+            L[i, k] = Uik = U[i, k]
+
+            for j in range(k + 1, m):
+                U[i, j] = (Ukk * U[i, j] - U[k, j] * Uik) / oldpivot
+
+            U[i, k] = 0
+
+        oldpivot = Ukk
+
+    DD[n - 1, n - 1] = oldpivot
+
+    return P, L, DD, U
+
+def _singular_value_decomposition(A):
+    r"""Returns a Condensed Singular Value decomposition.
+
+    Explanation
+    ===========
+
+    A Singular Value decomposition is a decomposition in the form $A = U \Sigma V^H$
+    where
+
+    - $U, V$ are column orthogonal matrix.
+    - $\Sigma$ is a diagonal matrix, where the main diagonal contains singular
+      values of matrix A.
+
+    A column orthogonal matrix satisfies
+    $\mathbb{I} = U^H U$ while a full orthogonal matrix satisfies
+    relation $\mathbb{I} = U U^H = U^H U$ where $\mathbb{I}$ is an identity
+    matrix with matching dimensions.
+
+    For matrices which are not square or are rank-deficient, it is
+    sufficient to return a column orthogonal matrix because augmenting
+    them may introduce redundant computations.
+    In condensed Singular Value Decomposition we only return column orthogonal
+    matrices because of this reason
+
+    If you want to augment the results to return a full orthogonal
+    decomposition, you should use the following procedures.
+
+    - Augment the $U, V$ matrices with columns that are orthogonal to every
+      other columns and make it square.
+    - Augment the $\Sigma$ matrix with zero rows to make it have the same
+      shape as the original matrix.
+
+    The procedure will be illustrated in the examples section.
+
+    Examples
+    ========
+
+    we take a full rank matrix first:
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[1, 2],[2,1]])
+    >>> U, S, V = A.singular_value_decomposition()
+    >>> U
+    Matrix([
+    [ sqrt(2)/2, sqrt(2)/2],
+    [-sqrt(2)/2, sqrt(2)/2]])
+    >>> S
+    Matrix([
+    [1, 0],
+    [0, 3]])
+    >>> V
+    Matrix([
+    [-sqrt(2)/2, sqrt(2)/2],
+    [ sqrt(2)/2, sqrt(2)/2]])
+
+    If a matrix if square and full rank both U, V
+    are orthogonal in both directions
+
+    >>> U * U.H
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> U.H * U
+    Matrix([
+    [1, 0],
+    [0, 1]])
+
+    >>> V * V.H
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> V.H * V
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> A == U * S * V.H
+    True
+
+    >>> C = Matrix([
+    ...         [1, 0, 0, 0, 2],
+    ...         [0, 0, 3, 0, 0],
+    ...         [0, 0, 0, 0, 0],
+    ...         [0, 2, 0, 0, 0],
+    ...     ])
+    >>> U, S, V = C.singular_value_decomposition()
+
+    >>> V.H * V
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> V * V.H
+    Matrix([
+    [1/5, 0, 0, 0, 2/5],
+    [  0, 1, 0, 0,   0],
+    [  0, 0, 1, 0,   0],
+    [  0, 0, 0, 0,   0],
+    [2/5, 0, 0, 0, 4/5]])
+
+    If you want to augment the results to be a full orthogonal
+    decomposition, you should augment $V$ with an another orthogonal
+    column.
+
+    You are able to append an arbitrary standard basis that are linearly
+    independent to every other columns and you can run the Gram-Schmidt
+    process to make them augmented as orthogonal basis.
+
+    >>> V_aug = V.row_join(Matrix([[0,0,0,0,1],
+    ... [0,0,0,1,0]]).H)
+    >>> V_aug = V_aug.QRdecomposition()[0]
+    >>> V_aug
+    Matrix([
+    [0,   sqrt(5)/5, 0, -2*sqrt(5)/5, 0],
+    [1,           0, 0,            0, 0],
+    [0,           0, 1,            0, 0],
+    [0,           0, 0,            0, 1],
+    [0, 2*sqrt(5)/5, 0,    sqrt(5)/5, 0]])
+    >>> V_aug.H * V_aug
+    Matrix([
+    [1, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0],
+    [0, 0, 1, 0, 0],
+    [0, 0, 0, 1, 0],
+    [0, 0, 0, 0, 1]])
+    >>> V_aug * V_aug.H
+    Matrix([
+    [1, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0],
+    [0, 0, 1, 0, 0],
+    [0, 0, 0, 1, 0],
+    [0, 0, 0, 0, 1]])
+
+    Similarly we augment U
+
+    >>> U_aug = U.row_join(Matrix([0,0,1,0]))
+    >>> U_aug = U_aug.QRdecomposition()[0]
+    >>> U_aug
+    Matrix([
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1],
+    [1, 0, 0, 0]])
+
+    >>> U_aug.H * U_aug
+    Matrix([
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1]])
+    >>> U_aug * U_aug.H
+    Matrix([
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1]])
+
+    We add 2 zero columns and one row to S
+
+    >>> S_aug = S.col_join(Matrix([[0,0,0]]))
+    >>> S_aug = S_aug.row_join(Matrix([[0,0,0,0],
+    ... [0,0,0,0]]).H)
+    >>> S_aug
+    Matrix([
+    [2,       0, 0, 0, 0],
+    [0, sqrt(5), 0, 0, 0],
+    [0,       0, 3, 0, 0],
+    [0,       0, 0, 0, 0]])
+
+
+
+    >>> U_aug * S_aug * V_aug.H == C
+    True
+
+    """
+
+    AH = A.H
+    m, n = A.shape
+    if m >= n:
+        V, S = (AH * A).diagonalize()
+
+        ranked = []
+        for i, x in enumerate(S.diagonal()):
+            if not x.is_zero:
+                ranked.append(i)
+
+        V = V[:, ranked]
+
+        Singular_vals = [sqrt(S[i, i]) for i in range(S.rows) if i in ranked]
+
+        S = S.diag(*Singular_vals)
+        V, _ = V.QRdecomposition()
+        U = A * V * S.inv()
+    else:
+        U, S = (A * AH).diagonalize()
+
+        ranked = []
+        for i, x in enumerate(S.diagonal()):
+            if not x.is_zero:
+                ranked.append(i)
+
+        U = U[:, ranked]
+        Singular_vals = [sqrt(S[i, i]) for i in range(S.rows) if i in ranked]
+
+        S = S.diag(*Singular_vals)
+        U, _ = U.QRdecomposition()
+        V = AH * U * S.inv()
+
+    return U, S, V
+
+def _QRdecomposition_optional(M, normalize=True):
+    def dot(u, v):
+        return u.dot(v, hermitian=True)
+
+    dps = _get_intermediate_simp(expand_mul, expand_mul)
+
+    A = M.as_mutable()
+    ranked = []
+
+    Q = A
+    R = A.zeros(A.cols)
+
+    for j in range(A.cols):
+        for i in range(j):
+            if Q[:, i].is_zero_matrix:
+                continue
+
+            R[i, j] = dot(Q[:, i], Q[:, j]) / dot(Q[:, i], Q[:, i])
+            R[i, j] = dps(R[i, j])
+            Q[:, j] -= Q[:, i] * R[i, j]
+
+        Q[:, j] = dps(Q[:, j])
+        if Q[:, j].is_zero_matrix is not True:
+            ranked.append(j)
+            R[j, j] = M.one
+
+    Q = Q.extract(range(Q.rows), ranked)
+    R = R.extract(ranked, range(R.cols))
+
+    if normalize:
+        # Normalization
+        for i in range(Q.cols):
+            norm = Q[:, i].norm()
+            Q[:, i] /= norm
+            R[i, :] *= norm
+
+    return M.__class__(Q), M.__class__(R)
+
+
+def _QRdecomposition(M):
+    r"""Returns a QR decomposition.
+
+    Explanation
+    ===========
+
+    A QR decomposition is a decomposition in the form $A = Q R$
+    where
+
+    - $Q$ is a column orthogonal matrix.
+    - $R$ is a upper triangular (trapezoidal) matrix.
+
+    A column orthogonal matrix satisfies
+    $\mathbb{I} = Q^H Q$ while a full orthogonal matrix satisfies
+    relation $\mathbb{I} = Q Q^H = Q^H Q$ where $I$ is an identity
+    matrix with matching dimensions.
+
+    For matrices which are not square or are rank-deficient, it is
+    sufficient to return a column orthogonal matrix because augmenting
+    them may introduce redundant computations.
+    And an another advantage of this is that you can easily inspect the
+    matrix rank by counting the number of columns of $Q$.
+
+    If you want to augment the results to return a full orthogonal
+    decomposition, you should use the following procedures.
+
+    - Augment the $Q$ matrix with columns that are orthogonal to every
+      other columns and make it square.
+    - Augment the $R$ matrix with zero rows to make it have the same
+      shape as the original matrix.
+
+    The procedure will be illustrated in the examples section.
+
+    Examples
+    ========
+
+    A full rank matrix example:
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([[12, -51, 4], [6, 167, -68], [-4, 24, -41]])
+    >>> Q, R = A.QRdecomposition()
+    >>> Q
+    Matrix([
+    [ 6/7, -69/175, -58/175],
+    [ 3/7, 158/175,   6/175],
+    [-2/7,    6/35,  -33/35]])
+    >>> R
+    Matrix([
+    [14,  21, -14],
+    [ 0, 175, -70],
+    [ 0,   0,  35]])
+
+    If the matrix is square and full rank, the $Q$ matrix becomes
+    orthogonal in both directions, and needs no augmentation.
+
+    >>> Q * Q.H
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> Q.H * Q
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    >>> A == Q*R
+    True
+
+    A rank deficient matrix example:
+
+    >>> A = Matrix([[12, -51, 0], [6, 167, 0], [-4, 24, 0]])
+    >>> Q, R = A.QRdecomposition()
+    >>> Q
+    Matrix([
+    [ 6/7, -69/175],
+    [ 3/7, 158/175],
+    [-2/7,    6/35]])
+    >>> R
+    Matrix([
+    [14,  21, 0],
+    [ 0, 175, 0]])
+
+    QRdecomposition might return a matrix Q that is rectangular.
+    In this case the orthogonality condition might be satisfied as
+    $\mathbb{I} = Q.H*Q$ but not in the reversed product
+    $\mathbb{I} = Q * Q.H$.
+
+    >>> Q.H * Q
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> Q * Q.H
+    Matrix([
+    [27261/30625,   348/30625, -1914/6125],
+    [  348/30625, 30589/30625,   198/6125],
+    [ -1914/6125,    198/6125,   136/1225]])
+
+    If you want to augment the results to be a full orthogonal
+    decomposition, you should augment $Q$ with an another orthogonal
+    column.
+
+    You are able to append an identity matrix,
+    and you can run the Gram-Schmidt
+    process to make them augmented as orthogonal basis.
+
+    >>> Q_aug = Q.row_join(Matrix.eye(3))
+    >>> Q_aug = Q_aug.QRdecomposition()[0]
+    >>> Q_aug
+    Matrix([
+    [ 6/7, -69/175, 58/175],
+    [ 3/7, 158/175, -6/175],
+    [-2/7,    6/35,  33/35]])
+    >>> Q_aug.H * Q_aug
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> Q_aug * Q_aug.H
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    Augmenting the $R$ matrix with zero row is straightforward.
+
+    >>> R_aug = R.col_join(Matrix([[0, 0, 0]]))
+    >>> R_aug
+    Matrix([
+    [14,  21, 0],
+    [ 0, 175, 0],
+    [ 0,   0, 0]])
+    >>> Q_aug * R_aug == A
+    True
+
+    A zero matrix example:
+
+    >>> from sympy import Matrix
+    >>> A = Matrix.zeros(3, 4)
+    >>> Q, R = A.QRdecomposition()
+
+    They may return matrices with zero rows and columns.
+
+    >>> Q
+    Matrix(3, 0, [])
+    >>> R
+    Matrix(0, 4, [])
+    >>> Q*R
+    Matrix([
+    [0, 0, 0, 0],
+    [0, 0, 0, 0],
+    [0, 0, 0, 0]])
+
+    As the same augmentation rule described above, $Q$ can be augmented
+    with columns of an identity matrix and $R$ can be augmented with
+    rows of a zero matrix.
+
+    >>> Q_aug = Q.row_join(Matrix.eye(3))
+    >>> R_aug = R.col_join(Matrix.zeros(3, 4))
+    >>> Q_aug * Q_aug.T
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> R_aug
+    Matrix([
+    [0, 0, 0, 0],
+    [0, 0, 0, 0],
+    [0, 0, 0, 0]])
+    >>> Q_aug * R_aug == A
+    True
+
+    See Also
+    ========
+
+    sympy.matrices.dense.DenseMatrix.cholesky
+    sympy.matrices.dense.DenseMatrix.LDLdecomposition
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    QRsolve
+    """
+    return _QRdecomposition_optional(M, normalize=True)
+
+def _upper_hessenberg_decomposition(A):
+    """Converts a matrix into Hessenberg matrix H.
+
+    Returns 2 matrices H, P s.t.
+    $P H P^{T} = A$, where H is an upper hessenberg matrix
+    and P is an orthogonal matrix
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> A = Matrix([
+    ...     [1,2,3],
+    ...     [-3,5,6],
+    ...     [4,-8,9],
+    ... ])
+    >>> H, P = A.upper_hessenberg_decomposition()
+    >>> H
+    Matrix([
+    [1,    6/5,    17/5],
+    [5, 213/25, -134/25],
+    [0, 216/25,  137/25]])
+    >>> P
+    Matrix([
+    [1,    0,   0],
+    [0, -3/5, 4/5],
+    [0,  4/5, 3/5]])
+    >>> P * H * P.H == A
+    True
+
+
+    References
+    ==========
+
+    .. [#] https://mathworld.wolfram.com/HessenbergDecomposition.html
+    """
+
+    M = A.as_mutable()
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Matrix must be square.")
+
+    n = M.cols
+    P = M.eye(n)
+    H = M
+
+    for j in range(n - 2):
+
+        u = H[j + 1:, j]
+
+        if u[1:, :].is_zero_matrix:
+            continue
+
+        if sign(u[0]) != 0:
+            u[0] = u[0] + sign(u[0]) * u.norm()
+        else:
+            u[0] = u[0] + u.norm()
+
+        v = u / u.norm()
+
+        H[j + 1:, :] = H[j + 1:, :] - 2 * v * (v.H * H[j + 1:, :])
+        H[:, j + 1:] = H[:, j + 1:] - (H[:, j + 1:] * (2 * v)) * v.H
+        P[:, j + 1:] = P[:, j + 1:] - (P[:, j + 1:] * (2 * v)) * v.H
+
+    return H, P

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_blockmatrix.py

@@ -0,0 +1,469 @@
+from sympy.matrices.expressions.trace import Trace
+from sympy.testing.pytest import raises, slow
+from sympy.matrices.expressions.blockmatrix import (
+    block_collapse, bc_matmul, bc_block_plus_ident, BlockDiagMatrix,
+    BlockMatrix, bc_dist, bc_matadd, bc_transpose, bc_inverse,
+    blockcut, reblock_2x2, deblock)
+from sympy.matrices.expressions import (
+    MatrixSymbol, Identity, trace, det, ZeroMatrix, OneMatrix)
+from sympy.matrices.expressions.inverse import Inverse
+from sympy.matrices.expressions.matpow import MatPow
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.matrices.exceptions import NonInvertibleMatrixError
+from sympy.matrices import (
+    Matrix, ImmutableMatrix, ImmutableSparseMatrix, zeros)
+from sympy.core import Tuple, Expr, S, Function
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions import transpose, im, re
+
+i, j, k, l, m, n, p = symbols('i:n, p', integer=True)
+A = MatrixSymbol('A', n, n)
+B = MatrixSymbol('B', n, n)
+C = MatrixSymbol('C', n, n)
+D = MatrixSymbol('D', n, n)
+G = MatrixSymbol('G', n, n)
+H = MatrixSymbol('H', n, n)
+b1 = BlockMatrix([[G, H]])
+b2 = BlockMatrix([[G], [H]])
+
+def test_bc_matmul():
+    assert bc_matmul(H*b1*b2*G) == BlockMatrix([[(H*G*G + H*H*H)*G]])
+
+def test_bc_matadd():
+    assert bc_matadd(BlockMatrix([[G, H]]) + BlockMatrix([[H, H]])) == \
+            BlockMatrix([[G+H, H+H]])
+
+def test_bc_transpose():
+    assert bc_transpose(Transpose(BlockMatrix([[A, B], [C, D]]))) == \
+            BlockMatrix([[A.T, C.T], [B.T, D.T]])
+
+def test_bc_dist_diag():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', m, m)
+    C = MatrixSymbol('C', l, l)
+    X = BlockDiagMatrix(A, B, C)
+
+    assert bc_dist(X+X).equals(BlockDiagMatrix(2*A, 2*B, 2*C))
+
+def test_block_plus_ident():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, m)
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', m, m)
+    X = BlockMatrix([[A, B], [C, D]])
+    Z = MatrixSymbol('Z', n + m, n + m)
+    assert bc_block_plus_ident(X + Identity(m + n) + Z) == \
+            BlockDiagMatrix(Identity(n), Identity(m)) + X + Z
+
+def test_BlockMatrix():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', n, k)
+    C = MatrixSymbol('C', l, m)
+    D = MatrixSymbol('D', l, k)
+    M = MatrixSymbol('M', m + k, p)
+    N = MatrixSymbol('N', l + n, k + m)
+    X = BlockMatrix(Matrix([[A, B], [C, D]]))
+
+    assert X.__class__(*X.args) == X
+
+    # block_collapse does nothing on normal inputs
+    E = MatrixSymbol('E', n, m)
+    assert block_collapse(A + 2*E) == A + 2*E
+    F = MatrixSymbol('F', m, m)
+    assert block_collapse(E.T*A*F) == E.T*A*F
+
+    assert X.shape == (l + n, k + m)
+    assert X.blockshape == (2, 2)
+    assert transpose(X) == BlockMatrix(Matrix([[A.T, C.T], [B.T, D.T]]))
+    assert transpose(X).shape == X.shape[::-1]
+
+    # Test that BlockMatrices and MatrixSymbols can still mix
+    assert (X*M).is_MatMul
+    assert X._blockmul(M).is_MatMul
+    assert (X*M).shape == (n + l, p)
+    assert (X + N).is_MatAdd
+    assert X._blockadd(N).is_MatAdd
+    assert (X + N).shape == X.shape
+
+    E = MatrixSymbol('E', m, 1)
+    F = MatrixSymbol('F', k, 1)
+
+    Y = BlockMatrix(Matrix([[E], [F]]))
+
+    assert (X*Y).shape == (l + n, 1)
+    assert block_collapse(X*Y).blocks[0, 0] == A*E + B*F
+    assert block_collapse(X*Y).blocks[1, 0] == C*E + D*F
+
+    # block_collapse passes down into container objects, transposes, and inverse
+    assert block_collapse(transpose(X*Y)) == transpose(block_collapse(X*Y))
+    assert block_collapse(Tuple(X*Y, 2*X)) == (
+        block_collapse(X*Y), block_collapse(2*X))
+
+    # Make sure that MatrixSymbols will enter 1x1 BlockMatrix if it simplifies
+    Ab = BlockMatrix([[A]])
+    Z = MatrixSymbol('Z', *A.shape)
+    assert block_collapse(Ab + Z) == A + Z
+
+def test_block_collapse_explicit_matrices():
+    A = Matrix([[1, 2], [3, 4]])
+    assert block_collapse(BlockMatrix([[A]])) == A
+
+    A = ImmutableSparseMatrix([[1, 2], [3, 4]])
+    assert block_collapse(BlockMatrix([[A]])) == A
+
+def test_issue_17624():
+    a = MatrixSymbol("a", 2, 2)
+    z = ZeroMatrix(2, 2)
+    b = BlockMatrix([[a, z], [z, z]])
+    assert block_collapse(b * b) == BlockMatrix([[a**2, z], [z, z]])
+    assert block_collapse(b * b * b) == BlockMatrix([[a**3, z], [z, z]])
+
+def test_issue_18618():
+    A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert A == Matrix(BlockDiagMatrix(A))
+
+def test_BlockMatrix_trace():
+    A, B, C, D = [MatrixSymbol(s, 3, 3) for s in 'ABCD']
+    X = BlockMatrix([[A, B], [C, D]])
+    assert trace(X) == trace(A) + trace(D)
+    assert trace(BlockMatrix([ZeroMatrix(n, n)])) == 0
+
+def test_BlockMatrix_Determinant():
+    A, B, C, D = [MatrixSymbol(s, 3, 3) for s in 'ABCD']
+    X = BlockMatrix([[A, B], [C, D]])
+    from sympy.assumptions.ask import Q
+    from sympy.assumptions.assume import assuming
+    with assuming(Q.invertible(A)):
+        assert det(X) == det(A) * det(X.schur('A'))
+
+    assert isinstance(det(X), Expr)
+    assert det(BlockMatrix([A])) == det(A)
+    assert det(BlockMatrix([ZeroMatrix(n, n)])) == 0
+
+def test_squareBlockMatrix():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, m)
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', m, m)
+    X = BlockMatrix([[A, B], [C, D]])
+    Y = BlockMatrix([[A]])
+
+    assert X.is_square
+
+    Q = X + Identity(m + n)
+    assert (block_collapse(Q) ==
+        BlockMatrix([[A + Identity(n), B], [C, D + Identity(m)]]))
+
+    assert (X + MatrixSymbol('Q', n + m, n + m)).is_MatAdd
+    assert (X * MatrixSymbol('Q', n + m, n + m)).is_MatMul
+
+    assert block_collapse(Y.I) == A.I
+
+    assert isinstance(X.inverse(), Inverse)
+
+    assert not X.is_Identity
+
+    Z = BlockMatrix([[Identity(n), B], [C, D]])
+    assert not Z.is_Identity
+
+
+def test_BlockMatrix_2x2_inverse_symbolic():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', n, k - m)
+    C = MatrixSymbol('C', k - n, m)
+    D = MatrixSymbol('D', k - n, k - m)
+    X = BlockMatrix([[A, B], [C, D]])
+    assert X.is_square and X.shape == (k, k)
+    assert isinstance(block_collapse(X.I), Inverse)  # Can't invert when none of the blocks is square
+
+    # test code path where only A is invertible
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, m)
+    C = MatrixSymbol('C', m, n)
+    D = ZeroMatrix(m, m)
+    X = BlockMatrix([[A, B], [C, D]])
+    assert block_collapse(X.inverse()) == BlockMatrix([
+        [A.I + A.I * B * X.schur('A').I * C * A.I, -A.I * B * X.schur('A').I],
+        [-X.schur('A').I * C * A.I, X.schur('A').I],
+    ])
+
+    # test code path where only B is invertible
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', n, n)
+    C = ZeroMatrix(m, m)
+    D = MatrixSymbol('D', m, n)
+    X = BlockMatrix([[A, B], [C, D]])
+    assert block_collapse(X.inverse()) == BlockMatrix([
+        [-X.schur('B').I * D * B.I, X.schur('B').I],
+        [B.I + B.I * A * X.schur('B').I * D * B.I, -B.I * A * X.schur('B').I],
+    ])
+
+    # test code path where only C is invertible
+    A = MatrixSymbol('A', n, m)
+    B = ZeroMatrix(n, n)
+    C = MatrixSymbol('C', m, m)
+    D = MatrixSymbol('D', m, n)
+    X = BlockMatrix([[A, B], [C, D]])
+    assert block_collapse(X.inverse()) == BlockMatrix([
+        [-C.I * D * X.schur('C').I, C.I + C.I * D * X.schur('C').I * A * C.I],
+        [X.schur('C').I, -X.schur('C').I * A * C.I],
+    ])
+
+    # test code path where only D is invertible
+    A = ZeroMatrix(n, n)
+    B = MatrixSymbol('B', n, m)
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', m, m)
+    X = BlockMatrix([[A, B], [C, D]])
+    assert block_collapse(X.inverse()) == BlockMatrix([
+        [X.schur('D').I, -X.schur('D').I * B * D.I],
+        [-D.I * C * X.schur('D').I, D.I + D.I * C * X.schur('D').I * B * D.I],
+    ])
+
+
+def test_BlockMatrix_2x2_inverse_numeric():
+    """Test 2x2 block matrix inversion numerically for all 4 formulas"""
+    M = Matrix([[1, 2], [3, 4]])
+    # rank deficient matrices that have full rank when two of them combined
+    D1 = Matrix([[1, 2], [2, 4]])
+    D2 = Matrix([[1, 3], [3, 9]])
+    D3 = Matrix([[1, 4], [4, 16]])
+    assert D1.rank() == D2.rank() == D3.rank() == 1
+    assert (D1 + D2).rank() == (D2 + D3).rank() == (D3 + D1).rank() == 2
+
+    # Only A is invertible
+    K = BlockMatrix([[M, D1], [D2, D3]])
+    assert block_collapse(K.inv()).as_explicit() == K.as_explicit().inv()
+    # Only B is invertible
+    K = BlockMatrix([[D1, M], [D2, D3]])
+    assert block_collapse(K.inv()).as_explicit() == K.as_explicit().inv()
+    # Only C is invertible
+    K = BlockMatrix([[D1, D2], [M, D3]])
+    assert block_collapse(K.inv()).as_explicit() == K.as_explicit().inv()
+    # Only D is invertible
+    K = BlockMatrix([[D1, D2], [D3, M]])
+    assert block_collapse(K.inv()).as_explicit() == K.as_explicit().inv()
+
+
+@slow
+def test_BlockMatrix_3x3_symbolic():
+    # Only test one of these, instead of all permutations, because it's slow
+    rowblocksizes = (n, m, k)
+    colblocksizes = (m, k, n)
+    K = BlockMatrix([
+        [MatrixSymbol('M%s%s' % (rows, cols), rows, cols) for cols in colblocksizes]
+        for rows in rowblocksizes
+    ])
+    collapse = block_collapse(K.I)
+    assert isinstance(collapse, BlockMatrix)
+
+
+def test_BlockDiagMatrix():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', m, m)
+    C = MatrixSymbol('C', l, l)
+    M = MatrixSymbol('M', n + m + l, n + m + l)
+
+    X = BlockDiagMatrix(A, B, C)
+    Y = BlockDiagMatrix(A, 2*B, 3*C)
+
+    assert X.blocks[1, 1] == B
+    assert X.shape == (n + m + l, n + m + l)
+    assert all(X.blocks[i, j].is_ZeroMatrix if i != j else X.blocks[i, j] in [A, B, C]
+            for i in range(3) for j in range(3))
+    assert X.__class__(*X.args) == X
+    assert X.get_diag_blocks() == (A, B, C)
+
+    assert isinstance(block_collapse(X.I * X), Identity)
+
+    assert bc_matmul(X*X) == BlockDiagMatrix(A*A, B*B, C*C)
+    assert block_collapse(X*X) == BlockDiagMatrix(A*A, B*B, C*C)
+    #XXX: should be == ??
+    assert block_collapse(X + X).equals(BlockDiagMatrix(2*A, 2*B, 2*C))
+    assert block_collapse(X*Y) == BlockDiagMatrix(A*A, 2*B*B, 3*C*C)
+    assert block_collapse(X + Y) == BlockDiagMatrix(2*A, 3*B, 4*C)
+
+    # Ensure that BlockDiagMatrices can still interact with normal MatrixExprs
+    assert (X*(2*M)).is_MatMul
+    assert (X + (2*M)).is_MatAdd
+
+    assert (X._blockmul(M)).is_MatMul
+    assert (X._blockadd(M)).is_MatAdd
+
+def test_BlockDiagMatrix_nonsquare():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', k, l)
+    X = BlockDiagMatrix(A, B)
+    assert X.shape == (n + k, m + l)
+    assert X.shape == (n + k, m + l)
+    assert X.rowblocksizes == [n, k]
+    assert X.colblocksizes == [m, l]
+    C = MatrixSymbol('C', n, m)
+    D = MatrixSymbol('D', k, l)
+    Y = BlockDiagMatrix(C, D)
+    assert block_collapse(X + Y) == BlockDiagMatrix(A + C, B + D)
+    assert block_collapse(X * Y.T) == BlockDiagMatrix(A * C.T, B * D.T)
+    raises(NonInvertibleMatrixError, lambda: BlockDiagMatrix(A, C.T).inverse())
+
+def test_BlockDiagMatrix_determinant():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', m, m)
+    assert det(BlockDiagMatrix()) == 1
+    assert det(BlockDiagMatrix(A)) == det(A)
+    assert det(BlockDiagMatrix(A, B)) == det(A) * det(B)
+
+    # non-square blocks
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', n, m)
+    assert det(BlockDiagMatrix(C, D)) == 0
+
+def test_BlockDiagMatrix_trace():
+    assert trace(BlockDiagMatrix()) == 0
+    assert trace(BlockDiagMatrix(ZeroMatrix(n, n))) == 0
+    A = MatrixSymbol('A', n, n)
+    assert trace(BlockDiagMatrix(A)) == trace(A)
+    B = MatrixSymbol('B', m, m)
+    assert trace(BlockDiagMatrix(A, B)) == trace(A) + trace(B)
+
+    # non-square blocks
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', n, m)
+    assert isinstance(trace(BlockDiagMatrix(C, D)), Trace)
+
+def test_BlockDiagMatrix_transpose():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', k, l)
+    assert transpose(BlockDiagMatrix()) == BlockDiagMatrix()
+    assert transpose(BlockDiagMatrix(A)) == BlockDiagMatrix(A.T)
+    assert transpose(BlockDiagMatrix(A, B)) == BlockDiagMatrix(A.T, B.T)
+
+def test_issue_2460():
+    bdm1 = BlockDiagMatrix(Matrix([i]), Matrix([j]))
+    bdm2 = BlockDiagMatrix(Matrix([k]), Matrix([l]))
+    assert block_collapse(bdm1 + bdm2) == BlockDiagMatrix(Matrix([i + k]), Matrix([j + l]))
+
+def test_blockcut():
+    A = MatrixSymbol('A', n, m)
+    B = blockcut(A, (n/2, n/2), (m/2, m/2))
+    assert B == BlockMatrix([[A[:n/2, :m/2], A[:n/2, m/2:]],
+                             [A[n/2:, :m/2], A[n/2:, m/2:]]])
+
+    M = ImmutableMatrix(4, 4, range(16))
+    B = blockcut(M, (2, 2), (2, 2))
+    assert M == ImmutableMatrix(B)
+
+    B = blockcut(M, (1, 3), (2, 2))
+    assert ImmutableMatrix(B.blocks[0, 1]) == ImmutableMatrix([[2, 3]])
+
+def test_reblock_2x2():
+    B = BlockMatrix([[MatrixSymbol('A_%d%d'%(i,j), 2, 2)
+                            for j in range(3)]
+                            for i in range(3)])
+    assert B.blocks.shape == (3, 3)
+
+    BB = reblock_2x2(B)
+    assert BB.blocks.shape == (2, 2)
+
+    assert B.shape == BB.shape
+    assert B.as_explicit() == BB.as_explicit()
+
+def test_deblock():
+    B = BlockMatrix([[MatrixSymbol('A_%d%d'%(i,j), n, n)
+                    for j in range(4)]
+                    for i in range(4)])
+
+    assert deblock(reblock_2x2(B)) == B
+
+def test_block_collapse_type():
+    bm1 = BlockDiagMatrix(ImmutableMatrix([1]), ImmutableMatrix([2]))
+    bm2 = BlockDiagMatrix(ImmutableMatrix([3]), ImmutableMatrix([4]))
+
+    assert bm1.T.__class__ == BlockDiagMatrix
+    assert block_collapse(bm1 - bm2).__class__ == BlockDiagMatrix
+    assert block_collapse(Inverse(bm1)).__class__ == BlockDiagMatrix
+    assert block_collapse(Transpose(bm1)).__class__ == BlockDiagMatrix
+    assert bc_transpose(Transpose(bm1)).__class__ == BlockDiagMatrix
+    assert bc_inverse(Inverse(bm1)).__class__ == BlockDiagMatrix
+
+def test_invalid_block_matrix():
+    raises(ValueError, lambda: BlockMatrix([
+        [Identity(2), Identity(5)],
+    ]))
+    raises(ValueError, lambda: BlockMatrix([
+        [Identity(n), Identity(m)],
+    ]))
+    raises(ValueError, lambda: BlockMatrix([
+        [ZeroMatrix(n, n), ZeroMatrix(n, n)],
+        [ZeroMatrix(n, n - 1), ZeroMatrix(n, n + 1)],
+    ]))
+    raises(ValueError, lambda: BlockMatrix([
+        [ZeroMatrix(n - 1, n), ZeroMatrix(n, n)],
+        [ZeroMatrix(n + 1, n), ZeroMatrix(n, n)],
+    ]))
+
+def test_block_lu_decomposition():
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, m)
+    C = MatrixSymbol('C', m, n)
+    D = MatrixSymbol('D', m, m)
+    X = BlockMatrix([[A, B], [C, D]])
+
+    #LDU decomposition
+    L, D, U = X.LDUdecomposition()
+    assert block_collapse(L*D*U) == X
+
+    #UDL decomposition
+    U, D, L = X.UDLdecomposition()
+    assert block_collapse(U*D*L) == X
+
+    #LU decomposition
+    L, U = X.LUdecomposition()
+    assert block_collapse(L*U) == X
+
+def test_issue_21866():
+    n  = 10
+    I  = Identity(n)
+    O  = ZeroMatrix(n, n)
+    A  = BlockMatrix([[  I,  O,  O,  O ],
+                      [  O,  I,  O,  O ],
+                      [  O,  O,  I,  O ],
+                      [  I,  O,  O,  I ]])
+    Ainv = block_collapse(A.inv())
+    AinvT = BlockMatrix([[  I,  O,  O,  O ],
+                      [  O,  I,  O,  O ],
+                      [  O,  O,  I,  O ],
+                      [  -I,  O,  O,  I ]])
+    assert Ainv == AinvT
+
+
+def test_adjoint_and_special_matrices():
+    A = Identity(3)
+    B = OneMatrix(3, 2)
+    C = ZeroMatrix(2, 3)
+    D = Identity(2)
+    X = BlockMatrix([[A, B], [C, D]])
+    X2 = BlockMatrix([[A, S.ImaginaryUnit*B], [C, D]])
+    assert X.adjoint() == BlockMatrix([[A, ZeroMatrix(3, 2)], [OneMatrix(2, 3), D]])
+    assert re(X) == X
+    assert X2.adjoint() == BlockMatrix([[A, ZeroMatrix(3, 2)], [-S.ImaginaryUnit*OneMatrix(2, 3), D]])
+    assert im(X2) == BlockMatrix([[ZeroMatrix(3, 3), OneMatrix(3, 2)], [ZeroMatrix(2, 3), ZeroMatrix(2, 2)]])
+
+
+def test_block_matrix_derivative():
+    x = symbols('x')
+    A = Matrix(3, 3, [Function(f'a{i}')(x) for i in range(9)])
+    bc = BlockMatrix([[A[:2, :2], A[:2, 2]], [A[2, :2], A[2:, 2]]])
+    assert Matrix(bc.diff(x)) - A.diff(x) == zeros(3, 3)
+
+
+def test_transpose_inverse_commute():
+    n = Symbol('n')
+    I = Identity(n)
+    Z = ZeroMatrix(n, n)
+    A = BlockMatrix([[I, Z], [Z, I]])
+
+    assert block_collapse(A.transpose().inverse()) == A
+    assert block_collapse(A.inverse().transpose()) == A
+
+    assert block_collapse(MatPow(A.transpose(), -2)) == MatPow(A, -2)
+    assert block_collapse(MatPow(A, -2).transpose()) == MatPow(A, -2)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_diagonal.py

@@ -0,0 +1,156 @@
+from sympy.matrices.expressions import MatrixSymbol
+from sympy.matrices.expressions.diagonal import DiagonalMatrix, DiagonalOf, DiagMatrix, diagonalize_vector
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.symbol import Symbol
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matmul import MatMul
+from sympy.matrices.expressions.special import Identity
+from sympy.testing.pytest import raises
+
+
+n = Symbol('n')
+m = Symbol('m')
+
+
+def test_DiagonalMatrix():
+    x = MatrixSymbol('x', n, m)
+    D = DiagonalMatrix(x)
+    assert D.diagonal_length is None
+    assert D.shape == (n, m)
+
+    x = MatrixSymbol('x', n, n)
+    D = DiagonalMatrix(x)
+    assert D.diagonal_length == n
+    assert D.shape == (n, n)
+    assert D[1, 2] == 0
+    assert D[1, 1] == x[1, 1]
+    i = Symbol('i')
+    j = Symbol('j')
+    x = MatrixSymbol('x', 3, 3)
+    ij = DiagonalMatrix(x)[i, j]
+    assert ij != 0
+    assert ij.subs({i:0, j:0}) == x[0, 0]
+    assert ij.subs({i:0, j:1}) == 0
+    assert ij.subs({i:1, j:1}) == x[1, 1]
+    assert ask(Q.diagonal(D))  # affirm that D is diagonal
+
+    x = MatrixSymbol('x', n, 3)
+    D = DiagonalMatrix(x)
+    assert D.diagonal_length == 3
+    assert D.shape == (n, 3)
+    assert D[2, m] == KroneckerDelta(2, m)*x[2, m]
+    assert D[3, m] == 0
+    raises(IndexError, lambda: D[m, 3])
+
+    x = MatrixSymbol('x', 3, n)
+    D = DiagonalMatrix(x)
+    assert D.diagonal_length == 3
+    assert D.shape == (3, n)
+    assert D[m, 2] == KroneckerDelta(m, 2)*x[m, 2]
+    assert D[m, 3] == 0
+    raises(IndexError, lambda: D[3, m])
+
+    x = MatrixSymbol('x', n, m)
+    D = DiagonalMatrix(x)
+    assert D.diagonal_length is None
+    assert D.shape == (n, m)
+    assert D[m, 4] != 0
+
+    x = MatrixSymbol('x', 3, 4)
+    assert [DiagonalMatrix(x)[i] for i in range(12)] == [
+        x[0, 0], 0, 0, 0, 0, x[1, 1], 0, 0, 0, 0, x[2, 2], 0]
+
+    # shape is retained, issue 12427
+    assert (
+        DiagonalMatrix(MatrixSymbol('x', 3, 4))*
+        DiagonalMatrix(MatrixSymbol('x', 4, 2))).shape == (3, 2)
+
+
+def test_DiagonalOf():
+    x = MatrixSymbol('x', n, n)
+    d = DiagonalOf(x)
+    assert d.shape == (n, 1)
+    assert d.diagonal_length == n
+    assert d[2, 0] == d[2] == x[2, 2]
+
+    x = MatrixSymbol('x', n, m)
+    d = DiagonalOf(x)
+    assert d.shape == (None, 1)
+    assert d.diagonal_length is None
+    assert d[2, 0] == d[2] == x[2, 2]
+
+    d = DiagonalOf(MatrixSymbol('x', 4, 3))
+    assert d.shape == (3, 1)
+    d = DiagonalOf(MatrixSymbol('x', n, 3))
+    assert d.shape == (3, 1)
+    d = DiagonalOf(MatrixSymbol('x', 3, n))
+    assert d.shape == (3, 1)
+    x = MatrixSymbol('x', n, m)
+    assert [DiagonalOf(x)[i] for i in range(4)] ==[
+        x[0, 0], x[1, 1], x[2, 2], x[3, 3]]
+
+
+def test_DiagMatrix():
+    x = MatrixSymbol('x', n, 1)
+    d = DiagMatrix(x)
+    assert d.shape == (n, n)
+    assert d[0, 1] == 0
+    assert d[0, 0] == x[0, 0]
+
+    a = MatrixSymbol('a', 1, 1)
+    d = diagonalize_vector(a)
+    assert isinstance(d, MatrixSymbol)
+    assert a == d
+    assert diagonalize_vector(Identity(3)) == Identity(3)
+    assert DiagMatrix(Identity(3)).doit() == Identity(3)
+    assert isinstance(DiagMatrix(Identity(3)), DiagMatrix)
+
+    # A diagonal matrix is equal to its transpose:
+    assert DiagMatrix(x).T == DiagMatrix(x)
+    assert diagonalize_vector(x.T) == DiagMatrix(x)
+
+    dx = DiagMatrix(x)
+    assert dx[0, 0] == x[0, 0]
+    assert dx[1, 1] == x[1, 0]
+    assert dx[0, 1] == 0
+    assert dx[0, m] == x[0, 0]*KroneckerDelta(0, m)
+
+    z = MatrixSymbol('z', 1, n)
+    dz = DiagMatrix(z)
+    assert dz[0, 0] == z[0, 0]
+    assert dz[1, 1] == z[0, 1]
+    assert dz[0, 1] == 0
+    assert dz[0, m] == z[0, m]*KroneckerDelta(0, m)
+
+    v = MatrixSymbol('v', 3, 1)
+    dv = DiagMatrix(v)
+    assert dv.as_explicit() == Matrix([
+        [v[0, 0], 0, 0],
+        [0, v[1, 0], 0],
+        [0, 0, v[2, 0]],
+    ])
+
+    v = MatrixSymbol('v', 1, 3)
+    dv = DiagMatrix(v)
+    assert dv.as_explicit() == Matrix([
+        [v[0, 0], 0, 0],
+        [0, v[0, 1], 0],
+        [0, 0, v[0, 2]],
+    ])
+
+    dv = DiagMatrix(3*v)
+    assert dv.args == (3*v,)
+    assert dv.doit() == 3*DiagMatrix(v)
+    assert isinstance(dv.doit(), MatMul)
+
+    a = MatrixSymbol("a", 3, 1).as_explicit()
+    expr = DiagMatrix(a)
+    result = Matrix([
+        [a[0, 0], 0, 0],
+        [0, a[1, 0], 0],
+        [0, 0, a[2, 0]],
+    ])
+    assert expr.doit() == result
+    expr = DiagMatrix(a.T)
+    assert expr.doit() == result

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_funcmatrix.py

@@ -0,0 +1,54 @@
+from sympy.core import symbols, Lambda
+from sympy.core.sympify import SympifyError
+from sympy.functions import KroneckerDelta
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import FunctionMatrix, MatrixExpr, Identity
+from sympy.testing.pytest import raises
+
+
+def test_funcmatrix_creation():
+    i, j, k = symbols('i j k')
+    assert FunctionMatrix(2, 2, Lambda((i, j), 0))
+    assert FunctionMatrix(0, 0, Lambda((i, j), 0))
+
+    raises(ValueError, lambda: FunctionMatrix(-1, 0, Lambda((i, j), 0)))
+    raises(ValueError, lambda: FunctionMatrix(2.0, 0, Lambda((i, j), 0)))
+    raises(ValueError, lambda: FunctionMatrix(2j, 0, Lambda((i, j), 0)))
+    raises(ValueError, lambda: FunctionMatrix(0, -1, Lambda((i, j), 0)))
+    raises(ValueError, lambda: FunctionMatrix(0, 2.0, Lambda((i, j), 0)))
+    raises(ValueError, lambda: FunctionMatrix(0, 2j, Lambda((i, j), 0)))
+
+    raises(ValueError, lambda: FunctionMatrix(2, 2, Lambda(i, 0)))
+    raises(SympifyError, lambda: FunctionMatrix(2, 2, lambda i, j: 0))
+    raises(ValueError, lambda: FunctionMatrix(2, 2, Lambda((i,), 0)))
+    raises(ValueError, lambda: FunctionMatrix(2, 2, Lambda((i, j, k), 0)))
+    raises(ValueError, lambda: FunctionMatrix(2, 2, i+j))
+    assert FunctionMatrix(2, 2, "lambda i, j: 0") == \
+        FunctionMatrix(2, 2, Lambda((i, j), 0))
+
+    m = FunctionMatrix(2, 2, KroneckerDelta)
+    assert m.as_explicit() == Identity(2).as_explicit()
+    assert m.args[2].dummy_eq(Lambda((i, j), KroneckerDelta(i, j)))
+
+    n = symbols('n')
+    assert FunctionMatrix(n, n, Lambda((i, j), 0))
+    n = symbols('n', integer=False)
+    raises(ValueError, lambda: FunctionMatrix(n, n, Lambda((i, j), 0)))
+    n = symbols('n', negative=True)
+    raises(ValueError, lambda: FunctionMatrix(n, n, Lambda((i, j), 0)))
+
+
+def test_funcmatrix():
+    i, j = symbols('i,j')
+    X = FunctionMatrix(3, 3, Lambda((i, j), i - j))
+    assert X[1, 1] == 0
+    assert X[1, 2] == -1
+    assert X.shape == (3, 3)
+    assert X.rows == X.cols == 3
+    assert Matrix(X) == Matrix(3, 3, lambda i, j: i - j)
+    assert isinstance(X*X + X, MatrixExpr)
+
+
+def test_replace_issue():
+    X = FunctionMatrix(3, 3, KroneckerDelta)
+    assert X.replace(lambda x: True, lambda x: x) == X

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_indexing.py

@@ -0,0 +1,299 @@
+from sympy.concrete.summations import Sum
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.matrices.dense import eye
+from sympy.matrices.expressions.blockmatrix import BlockMatrix
+from sympy.matrices.expressions.hadamard import HadamardPower
+from sympy.matrices.expressions.matexpr import (MatrixSymbol,
+    MatrixExpr, MatrixElement)
+from sympy.matrices.expressions.matpow import MatPow
+from sympy.matrices.expressions.special import (ZeroMatrix, Identity,
+    OneMatrix)
+from sympy.matrices.expressions.trace import Trace, trace
+from sympy.matrices.immutable import ImmutableMatrix
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+from sympy.testing.pytest import XFAIL, raises
+
+k, l, m, n = symbols('k l m n', integer=True)
+i, j = symbols('i j', integer=True)
+
+W = MatrixSymbol('W', k, l)
+X = MatrixSymbol('X', l, m)
+Y = MatrixSymbol('Y', l, m)
+Z = MatrixSymbol('Z', m, n)
+
+X1 = MatrixSymbol('X1', m, m)
+X2 = MatrixSymbol('X2', m, m)
+X3 = MatrixSymbol('X3', m, m)
+X4 = MatrixSymbol('X4', m, m)
+
+A = MatrixSymbol('A', 2, 2)
+B = MatrixSymbol('B', 2, 2)
+x = MatrixSymbol('x', 1, 2)
+y = MatrixSymbol('x', 2, 1)
+
+
+def test_symbolic_indexing():
+    x12 = X[1, 2]
+    assert all(s in str(x12) for s in ['1', '2', X.name])
+    # We don't care about the exact form of this.  We do want to make sure
+    # that all of these features are present
+
+
+def test_add_index():
+    assert (X + Y)[i, j] == X[i, j] + Y[i, j]
+
+
+def test_mul_index():
+    assert (A*y)[0, 0] == A[0, 0]*y[0, 0] + A[0, 1]*y[1, 0]
+    assert (A*B).as_mutable() == (A.as_mutable() * B.as_mutable())
+    X = MatrixSymbol('X', n, m)
+    Y = MatrixSymbol('Y', m, k)
+
+    result = (X*Y)[4,2]
+    expected = Sum(X[4, i]*Y[i, 2], (i, 0, m - 1))
+    assert result.args[0].dummy_eq(expected.args[0], i)
+    assert result.args[1][1:] == expected.args[1][1:]
+
+
+def test_pow_index():
+    Q = MatPow(A, 2)
+    assert Q[0, 0] == A[0, 0]**2 + A[0, 1]*A[1, 0]
+    n = symbols("n")
+    Q2 = A**n
+    assert Q2[0, 0] == 2*(
+            -sqrt((A[0, 0] + A[1, 1])**2 - 4*A[0, 0]*A[1, 1] +
+            4*A[0, 1]*A[1, 0])/2 + A[0, 0]/2 + A[1, 1]/2
+        )**n * \
+        A[0, 1]*A[1, 0]/(
+            (sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] +
+                  A[1, 1]**2) + A[0, 0] - A[1, 1])*
+            sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)
+        ) - 2*(
+            sqrt((A[0, 0] + A[1, 1])**2 - 4*A[0, 0]*A[1, 1] +
+            4*A[0, 1]*A[1, 0])/2 + A[0, 0]/2 + A[1, 1]/2
+        )**n * A[0, 1]*A[1, 0]/(
+            (-sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] +
+            A[1, 1]**2) + A[0, 0] - A[1, 1])*
+            sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)
+        )
+
+
+def test_transpose_index():
+    assert X.T[i, j] == X[j, i]
+
+
+def test_Identity_index():
+    I = Identity(3)
+    assert I[0, 0] == I[1, 1] == I[2, 2] == 1
+    assert I[1, 0] == I[0, 1] == I[2, 1] == 0
+    assert I[i, 0].delta_range == (0, 2)
+    raises(IndexError, lambda: I[3, 3])
+
+
+def test_block_index():
+    I = Identity(3)
+    Z = ZeroMatrix(3, 3)
+    B = BlockMatrix([[I, I], [I, I]])
+    e3 = ImmutableMatrix(eye(3))
+    BB = BlockMatrix([[e3, e3], [e3, e3]])
+    assert B[0, 0] == B[3, 0] == B[0, 3] == B[3, 3] == 1
+    assert B[4, 3] == B[5, 1] == 0
+
+    BB = BlockMatrix([[e3, e3], [e3, e3]])
+    assert B.as_explicit() == BB.as_explicit()
+
+    BI = BlockMatrix([[I, Z], [Z, I]])
+
+    assert BI.as_explicit().equals(eye(6))
+
+
+def test_block_index_symbolic():
+    # Note that these matrices may be zero-sized and indices may be negative, which causes
+    # all naive simplifications given in the comments to be invalid
+    A1 = MatrixSymbol('A1', n, k)
+    A2 = MatrixSymbol('A2', n, l)
+    A3 = MatrixSymbol('A3', m, k)
+    A4 = MatrixSymbol('A4', m, l)
+    A = BlockMatrix([[A1, A2], [A3, A4]])
+    assert A[0, 0] == MatrixElement(A, 0, 0)  # Cannot be A1[0, 0]
+    assert A[n - 1, k - 1] == A1[n - 1, k - 1]
+    assert A[n, k] == A4[0, 0]
+    assert A[n + m - 1, 0] == MatrixElement(A, n + m - 1, 0)  # Cannot be A3[m - 1, 0]
+    assert A[0, k + l - 1] == MatrixElement(A, 0, k + l - 1)  # Cannot be A2[0, l - 1]
+    assert A[n + m - 1, k + l - 1] == MatrixElement(A, n + m - 1, k + l - 1)  # Cannot be A4[m - 1, l - 1]
+    assert A[i, j] == MatrixElement(A, i, j)
+    assert A[n + i, k + j] == MatrixElement(A, n + i, k + j)  # Cannot be A4[i, j]
+    assert A[n - i - 1, k - j - 1] == MatrixElement(A, n - i - 1, k - j - 1)  # Cannot be A1[n - i - 1, k - j - 1]
+
+
+def test_block_index_symbolic_nonzero():
+    # All invalid simplifications from test_block_index_symbolic() that become valid if all
+    # matrices have nonzero size and all indices are nonnegative
+    k, l, m, n = symbols('k l m n', integer=True, positive=True)
+    i, j = symbols('i j', integer=True, nonnegative=True)
+    A1 = MatrixSymbol('A1', n, k)
+    A2 = MatrixSymbol('A2', n, l)
+    A3 = MatrixSymbol('A3', m, k)
+    A4 = MatrixSymbol('A4', m, l)
+    A = BlockMatrix([[A1, A2], [A3, A4]])
+    assert A[0, 0] == A1[0, 0]
+    assert A[n + m - 1, 0] == A3[m - 1, 0]
+    assert A[0, k + l - 1] == A2[0, l - 1]
+    assert A[n + m - 1, k + l - 1] == A4[m - 1, l - 1]
+    assert A[i, j] == MatrixElement(A, i, j)
+    assert A[n + i, k + j] == A4[i, j]
+    assert A[n - i - 1, k - j - 1] == A1[n - i - 1, k - j - 1]
+    assert A[2 * n, 2 * k] == A4[n, k]
+
+
+def test_block_index_large():
+    n, m, k = symbols('n m k', integer=True, positive=True)
+    i = symbols('i', integer=True, nonnegative=True)
+    A1 = MatrixSymbol('A1', n, n)
+    A2 = MatrixSymbol('A2', n, m)
+    A3 = MatrixSymbol('A3', n, k)
+    A4 = MatrixSymbol('A4', m, n)
+    A5 = MatrixSymbol('A5', m, m)
+    A6 = MatrixSymbol('A6', m, k)
+    A7 = MatrixSymbol('A7', k, n)
+    A8 = MatrixSymbol('A8', k, m)
+    A9 = MatrixSymbol('A9', k, k)
+    A = BlockMatrix([[A1, A2, A3], [A4, A5, A6], [A7, A8, A9]])
+    assert A[n + i, n + i] == MatrixElement(A, n + i, n + i)
+
+
+@XFAIL
+def test_block_index_symbolic_fail():
+    # To make this work, symbolic matrix dimensions would need to be somehow assumed nonnegative
+    # even if the symbols aren't specified as such.  Then 2 * n < n would correctly evaluate to
+    # False in BlockMatrix._entry()
+    A1 = MatrixSymbol('A1', n, 1)
+    A2 = MatrixSymbol('A2', m, 1)
+    A = BlockMatrix([[A1], [A2]])
+    assert A[2 * n, 0] == A2[n, 0]
+
+
+def test_slicing():
+    A.as_explicit()[0, :]  # does not raise an error
+
+
+def test_errors():
+    raises(IndexError, lambda: Identity(2)[1, 2, 3, 4, 5])
+    raises(IndexError, lambda: Identity(2)[[1, 2, 3, 4, 5]])
+
+
+def test_matrix_expression_to_indices():
+    i, j = symbols("i, j")
+    i1, i2, i3 = symbols("i_1:4")
+
+    def replace_dummies(expr):
+        repl = {i: Symbol(i.name) for i in expr.atoms(Dummy)}
+        return expr.xreplace(repl)
+
+    expr = W*X*Z
+    assert replace_dummies(expr._entry(i, j)) == \
+        Sum(W[i, i1]*X[i1, i2]*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr._entry(i, j)) == expr
+
+    expr = Z.T*X.T*W.T
+    assert replace_dummies(expr._entry(i, j)) == \
+        Sum(W[j, i2]*X[i2, i1]*Z[i1, i], (i1, 0, m-1), (i2, 0, l-1))
+    assert MatrixExpr.from_index_summation(expr._entry(i, j), i) == expr
+
+    expr = W*X*Z + W*Y*Z
+    assert replace_dummies(expr._entry(i, j)) == \
+        Sum(W[i, i1]*X[i1, i2]*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1)) +\
+        Sum(W[i, i1]*Y[i1, i2]*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr._entry(i, j)) == expr
+
+    expr = 2*W*X*Z + 3*W*Y*Z
+    assert replace_dummies(expr._entry(i, j)) == \
+        2*Sum(W[i, i1]*X[i1, i2]*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1)) +\
+        3*Sum(W[i, i1]*Y[i1, i2]*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr._entry(i, j)) == expr
+
+    expr = W*(X + Y)*Z
+    assert replace_dummies(expr._entry(i, j)) == \
+            Sum(W[i, i1]*(X[i1, i2] + Y[i1, i2])*Z[i2, j], (i1, 0, l-1), (i2, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr._entry(i, j)) == expr
+
+    expr = A*B**2*A
+    #assert replace_dummies(expr._entry(i, j)) == \
+    #        Sum(A[i, i1]*B[i1, i2]*B[i2, i3]*A[i3, j], (i1, 0, 1), (i2, 0, 1), (i3, 0, 1))
+
+    # Check that different dummies are used in sub-multiplications:
+    expr = (X1*X2 + X2*X1)*X3
+    assert replace_dummies(expr._entry(i, j)) == \
+           Sum((Sum(X1[i, i2] * X2[i2, i1], (i2, 0, m - 1)) + Sum(X1[i3, i1] * X2[i, i3], (i3, 0, m - 1))) * X3[
+               i1, j], (i1, 0, m - 1))
+
+
+def test_matrix_expression_from_index_summation():
+    from sympy.abc import a,b,c,d
+    A = MatrixSymbol("A", k, k)
+    B = MatrixSymbol("B", k, k)
+    C = MatrixSymbol("C", k, k)
+    w1 = MatrixSymbol("w1", k, 1)
+
+    i0, i1, i2, i3, i4 = symbols("i0:5", cls=Dummy)
+
+    expr = Sum(W[a,b]*X[b,c]*Z[c,d], (b, 0, l-1), (c, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr, a) == W*X*Z
+    expr = Sum(W.T[b,a]*X[b,c]*Z[c,d], (b, 0, l-1), (c, 0, m-1))
+    assert MatrixExpr.from_index_summation(expr, a) == W*X*Z
+    expr = Sum(A[b, a]*B[b, c]*C[c, d], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixSymbol.from_index_summation(expr, a) == A.T*B*C
+    expr = Sum(A[b, a]*B[c, b]*C[c, d], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixSymbol.from_index_summation(expr, a) == A.T*B.T*C
+    expr = Sum(C[c, d]*A[b, a]*B[c, b], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixSymbol.from_index_summation(expr, a) == A.T*B.T*C
+    expr = Sum(A[a, b] + B[a, b], (a, 0, k-1), (b, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == OneMatrix(1, k)*A*OneMatrix(k, 1) + OneMatrix(1, k)*B*OneMatrix(k, 1)
+    expr = Sum(A[a, b]**2, (a, 0, k - 1), (b, 0, k - 1))
+    assert MatrixExpr.from_index_summation(expr, a) == Trace(A * A.T)
+    expr = Sum(A[a, b]**3, (a, 0, k - 1), (b, 0, k - 1))
+    assert MatrixExpr.from_index_summation(expr, a) == Trace(HadamardPower(A.T, 2) * A)
+    expr = Sum((A[a, b] + B[a, b])*C[b, c], (b, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == (A+B)*C
+    expr = Sum((A[a, b] + B[b, a])*C[b, c], (b, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == (A+B.T)*C
+    expr = Sum(A[a, b]*A[b, c]*A[c, d], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == A**3
+    expr = Sum(A[a, b]*A[b, c]*B[c, d], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == A**2*B
+
+    # Parse the trace of a matrix:
+
+    expr = Sum(A[a, a], (a, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, None) == trace(A)
+    expr = Sum(A[a, a]*B[b, c]*C[c, d], (a, 0, k-1), (c, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, b) == trace(A)*B*C
+
+    # Check wrong sum ranges (should raise an exception):
+
+    ## Case 1: 0 to m instead of 0 to m-1
+    expr = Sum(W[a,b]*X[b,c]*Z[c,d], (b, 0, l-1), (c, 0, m))
+    raises(ValueError, lambda: MatrixExpr.from_index_summation(expr, a))
+    ## Case 2: 1 to m-1 instead of 0 to m-1
+    expr = Sum(W[a,b]*X[b,c]*Z[c,d], (b, 0, l-1), (c, 1, m-1))
+    raises(ValueError, lambda: MatrixExpr.from_index_summation(expr, a))
+
+    # Parse nested sums:
+    expr = Sum(A[a, b]*Sum(B[b, c]*C[c, d], (c, 0, k-1)), (b, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == A*B*C
+
+    # Test Kronecker delta:
+    expr = Sum(A[a, b]*KroneckerDelta(b, c)*B[c, d], (b, 0, k-1), (c, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, a) == A*B
+
+    expr = Sum(KroneckerDelta(i1, m)*KroneckerDelta(i2, n)*A[i, i1]*A[j, i2], (i1, 0, k-1), (i2, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, m) == ArrayTensorProduct(A.T, A)
+
+    # Test numbered indices:
+    expr = Sum(A[i1, i2]*w1[i2, 0], (i2, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, i1) == MatrixElement(A*w1, i1, 0)
+
+    expr = Sum(A[i1, i2]*B[i2, 0], (i2, 0, k-1))
+    assert MatrixExpr.from_index_summation(expr, i1) == MatrixElement(A*B, i1, 0)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_matadd.py

@@ -0,0 +1,58 @@
+from sympy.matrices.expressions import MatrixSymbol, MatAdd, MatPow, MatMul
+from sympy.matrices.expressions.special import GenericZeroMatrix, ZeroMatrix
+from sympy.matrices.exceptions import ShapeError
+from sympy.matrices import eye, ImmutableMatrix
+from sympy.core import Add, Basic, S
+from sympy.core.add import add
+from sympy.testing.pytest import XFAIL, raises
+
+X = MatrixSymbol('X', 2, 2)
+Y = MatrixSymbol('Y', 2, 2)
+
+def test_evaluate():
+    assert MatAdd(X, X, evaluate=True) == add(X, X, evaluate=True) == MatAdd(X, X).doit()
+
+def test_sort_key():
+    assert MatAdd(Y, X).doit().args == add(Y, X).doit().args == (X, Y)
+
+
+def test_matadd_sympify():
+    assert isinstance(MatAdd(eye(1), eye(1)).args[0], Basic)
+    assert isinstance(add(eye(1), eye(1)).args[0], Basic)
+
+
+def test_matadd_of_matrices():
+    assert MatAdd(eye(2), 4*eye(2), eye(2)).doit() == ImmutableMatrix(6*eye(2))
+    assert add(eye(2), 4*eye(2), eye(2)).doit() == ImmutableMatrix(6*eye(2))
+
+
+def test_doit_args():
+    A = ImmutableMatrix([[1, 2], [3, 4]])
+    B = ImmutableMatrix([[2, 3], [4, 5]])
+    assert MatAdd(A, MatPow(B, 2)).doit() == A + B**2
+    assert MatAdd(A, MatMul(A, B)).doit() == A + A*B
+    assert (MatAdd(A, X, MatMul(A, B), Y, MatAdd(2*A, B)).doit() ==
+    add(A, X, MatMul(A, B), Y, add(2*A, B)).doit() ==
+    MatAdd(3*A + A*B + B, X, Y))
+
+
+def test_generic_identity():
+    assert MatAdd.identity == GenericZeroMatrix()
+    assert MatAdd.identity != S.Zero
+
+
+def test_zero_matrix_add():
+    assert Add(ZeroMatrix(2, 2), ZeroMatrix(2, 2)) == ZeroMatrix(2, 2)
+
+@XFAIL
+def test_matrix_Add_with_scalar():
+    raises(TypeError, lambda: Add(0, ZeroMatrix(2, 2)))
+
+
+def test_shape_error():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 3, 3)
+    raises(ShapeError, lambda: MatAdd(A, B))
+
+    A = MatrixSymbol('A', 3, 2)
+    raises(ShapeError, lambda: MatAdd(A, B))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_matexpr.py

@@ -0,0 +1,592 @@
+from sympy.concrete.summations import Sum
+from sympy.core.exprtools import gcd_terms
+from sympy.core.function import (diff, expand)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Dummy, Symbol, Str)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.matrices.dense import zeros
+from sympy.polys.polytools import factor
+
+from sympy.core import (S, symbols, Add, Mul, SympifyError, Rational,
+                    Function)
+from sympy.functions import sin, cos, tan, sqrt, cbrt, exp
+from sympy.simplify import simplify
+from sympy.matrices import (ImmutableMatrix, Inverse, MatAdd, MatMul,
+        MatPow, Matrix, MatrixExpr, MatrixSymbol,
+        SparseMatrix, Transpose, Adjoint, MatrixSet)
+from sympy.matrices.exceptions import NonSquareMatrixError
+from sympy.matrices.expressions.determinant import Determinant, det
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.matrices.expressions.special import ZeroMatrix, Identity
+from sympy.testing.pytest import raises, XFAIL, skip
+from importlib.metadata import version
+
+n, m, l, k, p = symbols('n m l k p', integer=True)
+x = symbols('x')
+A = MatrixSymbol('A', n, m)
+B = MatrixSymbol('B', m, l)
+C = MatrixSymbol('C', n, n)
+D = MatrixSymbol('D', n, n)
+E = MatrixSymbol('E', m, n)
+w = MatrixSymbol('w', n, 1)
+
+
+def test_matrix_symbol_creation():
+    assert MatrixSymbol('A', 2, 2)
+    assert MatrixSymbol('A', 0, 0)
+    raises(ValueError, lambda: MatrixSymbol('A', -1, 2))
+    raises(ValueError, lambda: MatrixSymbol('A', 2.0, 2))
+    raises(ValueError, lambda: MatrixSymbol('A', 2j, 2))
+    raises(ValueError, lambda: MatrixSymbol('A', 2, -1))
+    raises(ValueError, lambda: MatrixSymbol('A', 2, 2.0))
+    raises(ValueError, lambda: MatrixSymbol('A', 2, 2j))
+
+    n = symbols('n')
+    assert MatrixSymbol('A', n, n)
+    n = symbols('n', integer=False)
+    raises(ValueError, lambda: MatrixSymbol('A', n, n))
+    n = symbols('n', negative=True)
+    raises(ValueError, lambda: MatrixSymbol('A', n, n))
+
+
+def test_matexpr_properties():
+    assert A.shape == (n, m)
+    assert (A * B).shape == (n, l)
+    assert A[0, 1].indices == (0, 1)
+    assert A[0, 0].symbol == A
+    assert A[0, 0].symbol.name == 'A'
+
+
+def test_matexpr():
+    assert (x*A).shape == A.shape
+    assert (x*A).__class__ == MatMul
+    assert 2*A - A - A == ZeroMatrix(*A.shape)
+    assert (A*B).shape == (n, l)
+
+
+def test_matexpr_subs():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', m, l)
+    C = MatrixSymbol('C', m, l)
+
+    assert A.subs(n, m).shape == (m, m)
+    assert (A*B).subs(B, C) == A*C
+    assert (A*B).subs(l, n).is_square
+
+    W = MatrixSymbol("W", 3, 3)
+    X = MatrixSymbol("X", 2, 2)
+    Y = MatrixSymbol("Y", 1, 2)
+    Z = MatrixSymbol("Z", n, 2)
+    # no restrictions on Symbol replacement
+    assert X.subs(X, Y) == Y
+    # it might be better to just change the name
+    y = Str('y')
+    assert X.subs(Str("X"), y).args == (y, 2, 2)
+    # it's ok to introduce a wider matrix
+    assert X[1, 1].subs(X, W) == W[1, 1]
+    # but for a given MatrixExpression, only change
+    # name if indexing on the new shape is valid.
+    # Here, X is 2,2; Y is 1,2 and Y[1, 1] is out
+    # of range so an error is raised
+    raises(IndexError, lambda: X[1, 1].subs(X, Y))
+    # here, [0, 1] is in range so the subs succeeds
+    assert X[0, 1].subs(X, Y) == Y[0, 1]
+    # and here the size of n will accept any index
+    # in the first position
+    assert W[2, 1].subs(W, Z) == Z[2, 1]
+    # but not in the second position
+    raises(IndexError, lambda: W[2, 2].subs(W, Z))
+    # any matrix should raise if invalid
+    raises(IndexError, lambda: W[2, 2].subs(W, zeros(2)))
+
+    A = SparseMatrix([[1, 2], [3, 4]])
+    B = Matrix([[1, 2], [3, 4]])
+    C, D = MatrixSymbol('C', 2, 2), MatrixSymbol('D', 2, 2)
+
+    assert (C*D).subs({C: A, D: B}) == MatMul(A, B)
+
+
+def test_addition():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', n, m)
+
+    assert isinstance(A + B, MatAdd)
+    assert (A + B).shape == A.shape
+    assert isinstance(A - A + 2*B, MatMul)
+
+    raises(TypeError, lambda: A + 1)
+    raises(TypeError, lambda: 5 + A)
+    raises(TypeError, lambda: 5 - A)
+
+    assert A + ZeroMatrix(n, m) - A == ZeroMatrix(n, m)
+    raises(TypeError, lambda: ZeroMatrix(n, m) + S.Zero)
+
+
+def test_multiplication():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', m, l)
+    C = MatrixSymbol('C', n, n)
+
+    assert (2*A*B).shape == (n, l)
+    assert (A*0*B) == ZeroMatrix(n, l)
+    assert (2*A).shape == A.shape
+
+    assert A * ZeroMatrix(m, m) * B == ZeroMatrix(n, l)
+
+    assert C * Identity(n) * C.I == Identity(n)
+
+    assert B/2 == S.Half*B
+    raises(NotImplementedError, lambda: 2/B)
+
+    A = MatrixSymbol('A', n, n)
+    B = MatrixSymbol('B', n, n)
+    assert Identity(n) * (A + B) == A + B
+
+    assert A**2*A == A**3
+    assert A**2*(A.I)**3 == A.I
+    assert A**3*(A.I)**2 == A
+
+
+def test_MatPow():
+    A = MatrixSymbol('A', n, n)
+
+    AA = MatPow(A, 2)
+    assert AA.exp == 2
+    assert AA.base == A
+    assert (A**n).exp == n
+
+    assert A**0 == Identity(n)
+    assert A**1 == A
+    assert A**2 == AA
+    assert A**-1 == Inverse(A)
+    assert (A**-1)**-1 == A
+    assert (A**2)**3 == A**6
+    assert A**S.Half == sqrt(A)
+    assert A**Rational(1, 3) == cbrt(A)
+    raises(NonSquareMatrixError, lambda: MatrixSymbol('B', 3, 2)**2)
+
+
+def test_MatrixSymbol():
+    n, m, t = symbols('n,m,t')
+    X = MatrixSymbol('X', n, m)
+    assert X.shape == (n, m)
+    raises(TypeError, lambda: MatrixSymbol('X', n, m)(t))  # issue 5855
+    assert X.doit() == X
+
+
+def test_dense_conversion():
+    X = MatrixSymbol('X', 2, 2)
+    assert ImmutableMatrix(X) == ImmutableMatrix(2, 2, lambda i, j: X[i, j])
+    assert Matrix(X) == Matrix(2, 2, lambda i, j: X[i, j])
+
+
+def test_free_symbols():
+    assert (C*D).free_symbols == {C, D}
+
+
+def test_zero_matmul():
+    assert isinstance(S.Zero * MatrixSymbol('X', 2, 2), MatrixExpr)
+
+
+def test_matadd_simplify():
+    A = MatrixSymbol('A', 1, 1)
+    assert simplify(MatAdd(A, ImmutableMatrix([[sin(x)**2 + cos(x)**2]]))) == \
+        MatAdd(A, Matrix([[1]]))
+
+
+def test_matmul_simplify():
+    A = MatrixSymbol('A', 1, 1)
+    assert simplify(MatMul(A, ImmutableMatrix([[sin(x)**2 + cos(x)**2]]))) == \
+        MatMul(A, Matrix([[1]]))
+
+
+def test_invariants():
+    A = MatrixSymbol('A', n, m)
+    B = MatrixSymbol('B', m, l)
+    X = MatrixSymbol('X', n, n)
+    objs = [Identity(n), ZeroMatrix(m, n), A, MatMul(A, B), MatAdd(A, A),
+            Transpose(A), Adjoint(A), Inverse(X), MatPow(X, 2), MatPow(X, -1),
+            MatPow(X, 0)]
+    for obj in objs:
+        assert obj == obj.__class__(*obj.args)
+
+
+def test_matexpr_indexing():
+    A = MatrixSymbol('A', n, m)
+    A[1, 2]
+    A[l, k]
+    A[l + 1, k + 1]
+    A = MatrixSymbol('A', 2, 1)
+    for i in range(-2, 2):
+        for j in range(-1, 1):
+            A[i, j]
+
+
+def test_single_indexing():
+    A = MatrixSymbol('A', 2, 3)
+    assert A[1] == A[0, 1]
+    assert A[int(1)] == A[0, 1]
+    assert A[3] == A[1, 0]
+    assert list(A[:2, :2]) == [A[0, 0], A[0, 1], A[1, 0], A[1, 1]]
+    raises(IndexError, lambda: A[6])
+    raises(IndexError, lambda: A[n])
+    B = MatrixSymbol('B', n, m)
+    raises(IndexError, lambda: B[1])
+    B = MatrixSymbol('B', n, 3)
+    assert B[3] == B[1, 0]
+
+
+def test_MatrixElement_commutative():
+    assert A[0, 1]*A[1, 0] == A[1, 0]*A[0, 1]
+
+
+def test_MatrixSymbol_determinant():
+    A = MatrixSymbol('A', 4, 4)
+    assert A.as_explicit().det() == A[0, 0]*A[1, 1]*A[2, 2]*A[3, 3] - \
+        A[0, 0]*A[1, 1]*A[2, 3]*A[3, 2] - A[0, 0]*A[1, 2]*A[2, 1]*A[3, 3] + \
+        A[0, 0]*A[1, 2]*A[2, 3]*A[3, 1] + A[0, 0]*A[1, 3]*A[2, 1]*A[3, 2] - \
+        A[0, 0]*A[1, 3]*A[2, 2]*A[3, 1] - A[0, 1]*A[1, 0]*A[2, 2]*A[3, 3] + \
+        A[0, 1]*A[1, 0]*A[2, 3]*A[3, 2] + A[0, 1]*A[1, 2]*A[2, 0]*A[3, 3] - \
+        A[0, 1]*A[1, 2]*A[2, 3]*A[3, 0] - A[0, 1]*A[1, 3]*A[2, 0]*A[3, 2] + \
+        A[0, 1]*A[1, 3]*A[2, 2]*A[3, 0] + A[0, 2]*A[1, 0]*A[2, 1]*A[3, 3] - \
+        A[0, 2]*A[1, 0]*A[2, 3]*A[3, 1] - A[0, 2]*A[1, 1]*A[2, 0]*A[3, 3] + \
+        A[0, 2]*A[1, 1]*A[2, 3]*A[3, 0] + A[0, 2]*A[1, 3]*A[2, 0]*A[3, 1] - \
+        A[0, 2]*A[1, 3]*A[2, 1]*A[3, 0] - A[0, 3]*A[1, 0]*A[2, 1]*A[3, 2] + \
+        A[0, 3]*A[1, 0]*A[2, 2]*A[3, 1] + A[0, 3]*A[1, 1]*A[2, 0]*A[3, 2] - \
+        A[0, 3]*A[1, 1]*A[2, 2]*A[3, 0] - A[0, 3]*A[1, 2]*A[2, 0]*A[3, 1] + \
+        A[0, 3]*A[1, 2]*A[2, 1]*A[3, 0]
+
+    B = MatrixSymbol('B', 4, 4)
+    assert Determinant(A + B).doit() == det(A + B) == (A + B).det()
+
+
+def test_MatrixElement_diff():
+    assert (A[3, 0]*A[0, 0]).diff(A[0, 0]) == A[3, 0]
+
+
+def test_MatrixElement_doit():
+    u = MatrixSymbol('u', 2, 1)
+    v = ImmutableMatrix([3, 5])
+    assert u[0, 0].subs(u, v).doit() == v[0, 0]
+
+
+def test_identity_powers():
+    M = Identity(n)
+    assert MatPow(M, 3).doit() == M**3
+    assert M**n == M
+    assert MatPow(M, 0).doit() == M**2
+    assert M**-2 == M
+    assert MatPow(M, -2).doit() == M**0
+    N = Identity(3)
+    assert MatPow(N, 2).doit() == N**n
+    assert MatPow(N, 3).doit() == N
+    assert MatPow(N, -2).doit() == N**4
+    assert MatPow(N, 2).doit() == N**0
+
+
+def test_Zero_power():
+    z1 = ZeroMatrix(n, n)
+    assert z1**4 == z1
+    raises(ValueError, lambda:z1**-2)
+    assert z1**0 == Identity(n)
+    assert MatPow(z1, 2).doit() == z1**2
+    raises(ValueError, lambda:MatPow(z1, -2).doit())
+    z2 = ZeroMatrix(3, 3)
+    assert MatPow(z2, 4).doit() == z2**4
+    raises(ValueError, lambda:z2**-3)
+    assert z2**3 == MatPow(z2, 3).doit()
+    assert z2**0 == Identity(3)
+    raises(ValueError, lambda:MatPow(z2, -1).doit())
+
+
+def test_matrixelement_diff():
+    dexpr = diff((D*w)[k,0], w[p,0])
+
+    assert w[k, p].diff(w[k, p]) == 1
+    assert w[k, p].diff(w[0, 0]) == KroneckerDelta(0, k, (0, n-1))*KroneckerDelta(0, p, (0, 0))
+    _i_1 = Dummy("_i_1")
+    assert dexpr.dummy_eq(Sum(KroneckerDelta(_i_1, p, (0, n-1))*D[k, _i_1], (_i_1, 0, n - 1)))
+    assert dexpr.doit() == D[k, p]
+
+
+def test_MatrixElement_with_values():
+    x, y, z, w = symbols("x y z w")
+    M = Matrix([[x, y], [z, w]])
+    i, j = symbols("i, j")
+    Mij = M[i, j]
+    assert isinstance(Mij, MatrixElement)
+    Ms = SparseMatrix([[2, 3], [4, 5]])
+    msij = Ms[i, j]
+    assert isinstance(msij, MatrixElement)
+    for oi, oj in [(0, 0), (0, 1), (1, 0), (1, 1)]:
+        assert Mij.subs({i: oi, j: oj}) == M[oi, oj]
+        assert msij.subs({i: oi, j: oj}) == Ms[oi, oj]
+    A = MatrixSymbol("A", 2, 2)
+    assert A[0, 0].subs(A, M) == x
+    assert A[i, j].subs(A, M) == M[i, j]
+    assert M[i, j].subs(M, A) == A[i, j]
+
+    assert isinstance(M[3*i - 2, j], MatrixElement)
+    assert M[3*i - 2, j].subs({i: 1, j: 0}) == M[1, 0]
+    assert isinstance(M[i, 0], MatrixElement)
+    assert M[i, 0].subs(i, 0) == M[0, 0]
+    assert M[0, i].subs(i, 1) == M[0, 1]
+
+    assert M[i, j].diff(x) == Matrix([[1, 0], [0, 0]])[i, j]
+
+    raises(ValueError, lambda: M[i, 2])
+    raises(ValueError, lambda: M[i, -1])
+    raises(ValueError, lambda: M[2, i])
+    raises(ValueError, lambda: M[-1, i])
+
+
+def test_inv():
+    B = MatrixSymbol('B', 3, 3)
+    assert B.inv() == B**-1
+
+    # https://github.com/sympy/sympy/issues/19162
+    X = MatrixSymbol('X', 1, 1).as_explicit()
+    assert X.inv() == Matrix([[1/X[0, 0]]])
+
+    X = MatrixSymbol('X', 2, 2).as_explicit()
+    detX = X[0, 0]*X[1, 1] - X[0, 1]*X[1, 0]
+    invX = Matrix([[ X[1, 1], -X[0, 1]],
+                   [-X[1, 0],  X[0, 0]]]) / detX
+    assert X.inv() == invX
+
+
+@XFAIL
+def test_factor_expand():
+    A = MatrixSymbol("A", n, n)
+    B = MatrixSymbol("B", n, n)
+    expr1 = (A + B)*(C + D)
+    expr2 = A*C + B*C + A*D + B*D
+    assert expr1 != expr2
+    assert expand(expr1) == expr2
+    assert factor(expr2) == expr1
+
+    expr = B**(-1)*(A**(-1)*B**(-1) - A**(-1)*C*B**(-1))**(-1)*A**(-1)
+    I = Identity(n)
+    # Ideally we get the first, but we at least don't want a wrong answer
+    assert factor(expr) in [I - C, B**-1*(A**-1*(I - C)*B**-1)**-1*A**-1]
+
+def test_numpy_conversion():
+    try:
+        from numpy import array, array_equal
+    except ImportError:
+        skip('NumPy must be available to test creating matrices from ndarrays')
+    A = MatrixSymbol('A', 2, 2)
+    np_array = array([[MatrixElement(A, 0, 0), MatrixElement(A, 0, 1)],
+    [MatrixElement(A, 1, 0), MatrixElement(A, 1, 1)]])
+    assert array_equal(array(A), np_array)
+    assert array_equal(array(A, copy=True), np_array)
+    if(int(version('numpy').split('.')[0]) >= 2): #run this test only if numpy is new enough that copy variable is passed properly.
+        raises(TypeError, lambda: array(A, copy=False))
+
+def test_issue_2749():
+    A = MatrixSymbol("A", 5, 2)
+    assert (A.T * A).I.as_explicit() == Matrix([[(A.T * A).I[0, 0], (A.T * A).I[0, 1]], \
+    [(A.T * A).I[1, 0], (A.T * A).I[1, 1]]])
+
+
+def test_issue_2750():
+    x = MatrixSymbol('x', 1, 1)
+    assert (x.T*x).as_explicit()**-1 == Matrix([[x[0, 0]**(-2)]])
+
+
+def test_issue_7842():
+    A = MatrixSymbol('A', 3, 1)
+    B = MatrixSymbol('B', 2, 1)
+    assert Eq(A, B) == False
+    assert Eq(A[1,0], B[1, 0]).func is Eq
+    A = ZeroMatrix(2, 3)
+    B = ZeroMatrix(2, 3)
+    assert Eq(A, B) == True
+
+
+def test_issue_21195():
+    t = symbols('t')
+    x = Function('x')(t)
+    dx = x.diff(t)
+    exp1 = cos(x) + cos(x)*dx
+    exp2 = sin(x) + tan(x)*(dx.diff(t))
+    exp3 = sin(x)*sin(t)*(dx.diff(t)).diff(t)
+    A = Matrix([[exp1], [exp2], [exp3]])
+    B = Matrix([[exp1.diff(x)], [exp2.diff(x)], [exp3.diff(x)]])
+    assert A.diff(x) == B
+
+
+def test_issue_24859():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 3, 2)
+    J = A*B
+    Jinv = Matrix(J).adjugate()
+    u = MatrixSymbol('u', 2, 3)
+    Jk = Jinv.subs(A, A + x*u)
+
+    expected = B[0, 1]*u[1, 0] + B[1, 1]*u[1, 1] + B[2, 1]*u[1, 2]
+    assert Jk[0, 0].diff(x) == expected
+    assert diff(Jk[0, 0], x).doit() == expected
+
+
+def test_MatMul_postprocessor():
+    z = zeros(2)
+    z1 = ZeroMatrix(2, 2)
+    assert Mul(0, z) == Mul(z, 0) in [z, z1]
+
+    M = Matrix([[1, 2], [3, 4]])
+    Mx = Matrix([[x, 2*x], [3*x, 4*x]])
+    assert Mul(x, M) == Mul(M, x) == Mx
+
+    A = MatrixSymbol("A", 2, 2)
+    assert Mul(A, M) == MatMul(A, M)
+    assert Mul(M, A) == MatMul(M, A)
+    # Scalars should be absorbed into constant matrices
+    a = Mul(x, M, A)
+    b = Mul(M, x, A)
+    c = Mul(M, A, x)
+    assert a == b == c == MatMul(Mx, A)
+    a = Mul(x, A, M)
+    b = Mul(A, x, M)
+    c = Mul(A, M, x)
+    assert a == b == c == MatMul(A, Mx)
+    assert Mul(M, M) == M**2
+    assert Mul(A, M, M) == MatMul(A, M**2)
+    assert Mul(M, M, A) == MatMul(M**2, A)
+    assert Mul(M, A, M) == MatMul(M, A, M)
+
+    assert Mul(A, x, M, M, x) == MatMul(A, Mx**2)
+
+
+@XFAIL
+def test_MatAdd_postprocessor_xfail():
+    # This is difficult to get working because of the way that Add processes
+    # its args.
+    z = zeros(2)
+    assert Add(z, S.NaN) == Add(S.NaN, z)
+
+
+def test_MatAdd_postprocessor():
+    # Some of these are nonsensical, but we do not raise errors for Add
+    # because that breaks algorithms that want to replace matrices with dummy
+    # symbols.
+
+    z = zeros(2)
+
+    assert Add(0, z) == Add(z, 0) == z
+
+    a = Add(S.Infinity, z)
+    assert a == Add(z, S.Infinity)
+    assert isinstance(a, Add)
+    assert a.args == (S.Infinity, z)
+
+    a = Add(S.ComplexInfinity, z)
+    assert a == Add(z, S.ComplexInfinity)
+    assert isinstance(a, Add)
+    assert a.args == (S.ComplexInfinity, z)
+
+    a = Add(z, S.NaN)
+    # assert a == Add(S.NaN, z) # See the XFAIL above
+    assert isinstance(a, Add)
+    assert a.args == (S.NaN, z)
+
+    M = Matrix([[1, 2], [3, 4]])
+    a = Add(x, M)
+    assert a == Add(M, x)
+    assert isinstance(a, Add)
+    assert a.args == (x, M)
+
+    A = MatrixSymbol("A", 2, 2)
+    assert Add(A, M) == Add(M, A) == A + M
+
+    # Scalars should be absorbed into constant matrices (producing an error)
+    a = Add(x, M, A)
+    assert a == Add(M, x, A) == Add(M, A, x) == Add(x, A, M) == Add(A, x, M) == Add(A, M, x)
+    assert isinstance(a, Add)
+    assert a.args == (x, A + M)
+
+    assert Add(M, M) == 2*M
+    assert Add(M, A, M) == Add(M, M, A) == Add(A, M, M) == A + 2*M
+
+    a = Add(A, x, M, M, x)
+    assert isinstance(a, Add)
+    assert a.args == (2*x, A + 2*M)
+
+
+def test_simplify_matrix_expressions():
+    # Various simplification functions
+    assert type(gcd_terms(C*D + D*C)) == MatAdd
+    a = gcd_terms(2*C*D + 4*D*C)
+    assert type(a) == MatAdd
+    assert a.args == (2*C*D, 4*D*C)
+
+
+def test_exp():
+    A = MatrixSymbol('A', 2, 2)
+    B = MatrixSymbol('B', 2, 2)
+    expr1 = exp(A)*exp(B)
+    expr2 = exp(B)*exp(A)
+    assert expr1 != expr2
+    assert expr1 - expr2 != 0
+    assert not isinstance(expr1, exp)
+    assert not isinstance(expr2, exp)
+
+
+def test_invalid_args():
+    raises(SympifyError, lambda: MatrixSymbol(1, 2, 'A'))
+
+
+def test_matrixsymbol_from_symbol():
+    # The label should be preserved during doit and subs
+    A_label = Symbol('A', complex=True)
+    A = MatrixSymbol(A_label, 2, 2)
+
+    A_1 = A.doit()
+    A_2 = A.subs(2, 3)
+    assert A_1.args == A.args
+    assert A_2.args[0] == A.args[0]
+
+
+def test_as_explicit():
+    Z = MatrixSymbol('Z', 2, 3)
+    assert Z.as_explicit() == ImmutableMatrix([
+        [Z[0, 0], Z[0, 1], Z[0, 2]],
+        [Z[1, 0], Z[1, 1], Z[1, 2]],
+    ])
+    raises(ValueError, lambda: A.as_explicit())
+
+
+def test_MatrixSet():
+    M = MatrixSet(2, 2, set=S.Reals)
+    assert M.shape == (2, 2)
+    assert M.set == S.Reals
+    X = Matrix([[1, 2], [3, 4]])
+    assert X in M
+    X = ZeroMatrix(2, 2)
+    assert X in M
+    raises(TypeError, lambda: A in M)
+    raises(TypeError, lambda: 1 in M)
+    M = MatrixSet(n, m, set=S.Reals)
+    assert A in M
+    raises(TypeError, lambda: C in M)
+    raises(TypeError, lambda: X in M)
+    M = MatrixSet(2, 2, set={1, 2, 3})
+    X = Matrix([[1, 2], [3, 4]])
+    Y = Matrix([[1, 2]])
+    assert (X in M) == S.false
+    assert (Y in M) == S.false
+    raises(ValueError, lambda: MatrixSet(2, -2, S.Reals))
+    raises(ValueError, lambda: MatrixSet(2.4, -1, S.Reals))
+    raises(TypeError, lambda: MatrixSet(2, 2, (1, 2, 3)))
+
+
+def test_matrixsymbol_solving():
+    A = MatrixSymbol('A', 2, 2)
+    B = MatrixSymbol('B', 2, 2)
+    Z = ZeroMatrix(2, 2)
+    assert -(-A + B) - A + B == Z
+    assert (-(-A + B) - A + B).simplify() == Z
+    assert (-(-A + B) - A + B).expand() == Z
+    assert (-(-A + B) - A + B - Z).simplify() == Z
+    assert (-(-A + B) - A + B - Z).expand() == Z
+    assert (A*(A + B) + B*(A.T + B.T)).expand() == A**2 + A*B + B*A.T + B*B.T

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_matmul.py

@@ -0,0 +1,186 @@
+from sympy.core import I, symbols, Basic, Mul, S
+from sympy.core.mul import mul
+from sympy.functions import adjoint, transpose
+from sympy.matrices.exceptions import ShapeError
+from sympy.matrices import (Identity, Inverse, Matrix, MatrixSymbol, ZeroMatrix,
+        eye, ImmutableMatrix)
+from sympy.matrices.expressions import Adjoint, Transpose, det, MatPow
+from sympy.matrices.expressions.special import GenericIdentity
+from sympy.matrices.expressions.matmul import (factor_in_front, remove_ids,
+        MatMul, combine_powers, any_zeros, unpack, only_squares)
+from sympy.strategies import null_safe
+from sympy.assumptions.ask import Q
+from sympy.assumptions.refine import refine
+from sympy.core.symbol import Symbol
+
+from sympy.testing.pytest import XFAIL, raises
+
+n, m, l, k = symbols('n m l k', integer=True)
+x = symbols('x')
+A = MatrixSymbol('A', n, m)
+B = MatrixSymbol('B', m, l)
+C = MatrixSymbol('C', n, n)
+D = MatrixSymbol('D', n, n)
+E = MatrixSymbol('E', m, n)
+
+def test_evaluate():
+    assert MatMul(C, C, evaluate=True) == MatMul(C, C).doit()
+
+def test_adjoint():
+    assert adjoint(A*B) == Adjoint(B)*Adjoint(A)
+    assert adjoint(2*A*B) == 2*Adjoint(B)*Adjoint(A)
+    assert adjoint(2*I*C) == -2*I*Adjoint(C)
+
+    M = Matrix(2, 2, [1, 2 + I, 3, 4])
+    MA = Matrix(2, 2, [1, 3, 2 - I, 4])
+    assert adjoint(M) == MA
+    assert adjoint(2*M) == 2*MA
+    assert adjoint(MatMul(2, M)) == MatMul(2, MA).doit()
+
+
+def test_transpose():
+    assert transpose(A*B) == Transpose(B)*Transpose(A)
+    assert transpose(2*A*B) == 2*Transpose(B)*Transpose(A)
+    assert transpose(2*I*C) == 2*I*Transpose(C)
+
+    M = Matrix(2, 2, [1, 2 + I, 3, 4])
+    MT = Matrix(2, 2, [1, 3, 2 + I, 4])
+    assert transpose(M) == MT
+    assert transpose(2*M) == 2*MT
+    assert transpose(x*M) == x*MT
+    assert transpose(MatMul(2, M)) == MatMul(2, MT).doit()
+
+
+def test_factor_in_front():
+    assert factor_in_front(MatMul(A, 2, B, evaluate=False)) ==\
+                           MatMul(2, A, B, evaluate=False)
+
+
+def test_remove_ids():
+    assert remove_ids(MatMul(A, Identity(m), B, evaluate=False)) == \
+                      MatMul(A, B, evaluate=False)
+    assert null_safe(remove_ids)(MatMul(Identity(n), evaluate=False)) == \
+                                 MatMul(Identity(n), evaluate=False)
+
+
+def test_combine_powers():
+    assert combine_powers(MatMul(D, Inverse(D), D, evaluate=False)) == \
+                 MatMul(Identity(n), D, evaluate=False)
+    assert combine_powers(MatMul(B.T, Inverse(E*A), E, A, B, evaluate=False)) == \
+        MatMul(B.T, Identity(m), B, evaluate=False)
+    assert combine_powers(MatMul(A, E, Inverse(A*E), D, evaluate=False)) == \
+        MatMul(Identity(n), D, evaluate=False)
+
+
+def test_any_zeros():
+    assert any_zeros(MatMul(A, ZeroMatrix(m, k), evaluate=False)) == \
+                     ZeroMatrix(n, k)
+
+
+def test_unpack():
+    assert unpack(MatMul(A, evaluate=False)) == A
+    x = MatMul(A, B)
+    assert unpack(x) == x
+
+
+def test_only_squares():
+    assert only_squares(C) == [C]
+    assert only_squares(C, D) == [C, D]
+    assert only_squares(C, A, A.T, D) == [C, A*A.T, D]
+
+
+def test_determinant():
+    assert det(2*C) == 2**n*det(C)
+    assert det(2*C*D) == 2**n*det(C)*det(D)
+    assert det(3*C*A*A.T*D) == 3**n*det(C)*det(A*A.T)*det(D)
+
+
+def test_doit():
+    assert MatMul(C, 2, D).args == (C, 2, D)
+    assert MatMul(C, 2, D).doit().args == (2, C, D)
+    assert MatMul(C, Transpose(D*C)).args == (C, Transpose(D*C))
+    assert MatMul(C, Transpose(D*C)).doit(deep=True).args == (C, C.T, D.T)
+
+
+def test_doit_drills_down():
+    X = ImmutableMatrix([[1, 2], [3, 4]])
+    Y = ImmutableMatrix([[2, 3], [4, 5]])
+    assert MatMul(X, MatPow(Y, 2)).doit() == X*Y**2
+    assert MatMul(C, Transpose(D*C)).doit().args == (C, C.T, D.T)
+
+
+def test_doit_deep_false_still_canonical():
+    assert (MatMul(C, Transpose(D*C), 2).doit(deep=False).args ==
+            (2, C, Transpose(D*C)))
+
+
+def test_matmul_scalar_Matrix_doit():
+    # Issue 9053
+    X = Matrix([[1, 2], [3, 4]])
+    assert MatMul(2, X).doit() == 2*X
+
+
+def test_matmul_sympify():
+    assert isinstance(MatMul(eye(1), eye(1)).args[0], Basic)
+
+
+def test_collapse_MatrixBase():
+    A = Matrix([[1, 1], [1, 1]])
+    B = Matrix([[1, 2], [3, 4]])
+    assert MatMul(A, B).doit() == ImmutableMatrix([[4, 6], [4, 6]])
+
+
+def test_refine():
+    assert refine(C*C.T*D, Q.orthogonal(C)).doit() == D
+
+    kC = k*C
+    assert refine(kC*C.T, Q.orthogonal(C)).doit() == k*Identity(n)
+    assert refine(kC* kC.T, Q.orthogonal(C)).doit() == (k**2)*Identity(n)
+
+def test_matmul_no_matrices():
+    assert MatMul(1) == 1
+    assert MatMul(n, m) == n*m
+    assert not isinstance(MatMul(n, m), MatMul)
+
+def test_matmul_args_cnc():
+    assert MatMul(n, A, A.T).args_cnc() == [[n], [A, A.T]]
+    assert MatMul(A, A.T).args_cnc() == [[], [A, A.T]]
+
+@XFAIL
+def test_matmul_args_cnc_symbols():
+    # Not currently supported
+    a, b = symbols('a b', commutative=False)
+    assert MatMul(n, a, b, A, A.T).args_cnc() == [[n], [a, b, A, A.T]]
+    assert MatMul(n, a, A, b, A.T).args_cnc() == [[n], [a, A, b, A.T]]
+
+def test_issue_12950():
+    M = Matrix([[Symbol("x")]]) * MatrixSymbol("A", 1, 1)
+    assert MatrixSymbol("A", 1, 1).as_explicit()[0]*Symbol('x') == M.as_explicit()[0]
+
+def test_construction_with_Mul():
+    assert Mul(C, D) == MatMul(C, D)
+    assert Mul(D, C) == MatMul(D, C)
+
+def test_construction_with_mul():
+    assert mul(C, D) == MatMul(C, D)
+    assert mul(D, C) == MatMul(D, C)
+    assert mul(C, D) != MatMul(D, C)
+
+def test_generic_identity():
+    assert MatMul.identity == GenericIdentity()
+    assert MatMul.identity != S.One
+
+
+def test_issue_23519():
+    N = Symbol("N", integer=True)
+    M1 = MatrixSymbol("M1", N, N)
+    M2 = MatrixSymbol("M2", N, N)
+    I = Identity(N)
+    z = (M2 + 2 * (M2 + I) * M1 + I)
+    assert z.coeff(M1) == 2*I + 2*M2
+
+
+def test_shape_error():
+    A = MatrixSymbol('A', 2, 2)
+    B = MatrixSymbol('B', 3, 3)
+    raises(ShapeError, lambda: MatMul(A, B))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/sympy/matrices/expressions/tests/test_permutation.py

@@ -0,0 +1,166 @@
+from sympy.combinatorics import Permutation
+from sympy.core.expr import unchanged
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import \
+    MatMul, BlockDiagMatrix, Determinant, Inverse
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import ZeroMatrix, OneMatrix, Identity
+from sympy.matrices.expressions.permutation import \
+    MatrixPermute, PermutationMatrix
+from sympy.testing.pytest import raises
+from sympy.core.symbol import Symbol
+
+
+def test_PermutationMatrix_basic():
+    p = Permutation([1, 0])
+    assert unchanged(PermutationMatrix, p)
+    raises(ValueError, lambda: PermutationMatrix((0, 1, 2)))
+    assert PermutationMatrix(p).as_explicit() == Matrix([[0, 1], [1, 0]])
+    assert isinstance(PermutationMatrix(p)*MatrixSymbol('A', 2, 2), MatMul)
+
+
+def test_PermutationMatrix_matmul():
+    p = Permutation([1, 2, 0])
+    P = PermutationMatrix(p)
+    M = Matrix([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
+    assert (P*M).as_explicit() == P.as_explicit()*M
+    assert (M*P).as_explicit() == M*P.as_explicit()
+
+    P1 = PermutationMatrix(Permutation([1, 2, 0]))
+    P2 = PermutationMatrix(Permutation([2, 1, 0]))
+    P3 = PermutationMatrix(Permutation([1, 0, 2]))
+    assert P1*P2 == P3
+
+
+def test_PermutationMatrix_matpow():
+    p1 = Permutation([1, 2, 0])
+    P1 = PermutationMatrix(p1)
+    p2 = Permutation([2, 0, 1])
+    P2 = PermutationMatrix(p2)
+    assert P1**2 == P2
+    assert P1**3 == Identity(3)
+
+
+def test_PermutationMatrix_identity():
+    p = Permutation([0, 1])
+    assert PermutationMatrix(p).is_Identity
+
+    p = Permutation([1, 0])
+    assert not PermutationMatrix(p).is_Identity
+
+
+def test_PermutationMatrix_determinant():
+    P = PermutationMatrix(Permutation([0, 1, 2]))
+    assert Determinant(P).doit() == 1
+    P = PermutationMatrix(Permutation([0, 2, 1]))
+    assert Determinant(P).doit() == -1
+    P = PermutationMatrix(Permutation([2, 0, 1]))
+    assert Determinant(P).doit() == 1
+
+
+def test_PermutationMatrix_inverse():
+    P = PermutationMatrix(Permutation(0, 1, 2))
+    assert Inverse(P).doit() == PermutationMatrix(Permutation(0, 2, 1))
+
+
+def test_PermutationMatrix_rewrite_BlockDiagMatrix():
+    P = PermutationMatrix(Permutation([0, 1, 2, 3, 4, 5]))
+    P0 = PermutationMatrix(Permutation([0]))
+    assert P.rewrite(BlockDiagMatrix) == \
+        BlockDiagMatrix(P0, P0, P0, P0, P0, P0)
+
+    P = PermutationMatrix(Permutation([0, 1, 3, 2, 4, 5]))
+    P10 = PermutationMatrix(Permutation(0, 1))
+    assert P.rewrite(BlockDiagMatrix) == \
+        BlockDiagMatrix(P0, P0, P10, P0, P0)
+
+    P = PermutationMatrix(Permutation([1, 0, 3, 2, 5, 4]))
+    assert P.rewrite(BlockDiagMatrix) == \
+        BlockDiagMatrix(P10, P10, P10)
+
+    P = PermutationMatrix(Permutation([0, 4, 3, 2, 1, 5]))
+    P3210 = PermutationMatrix(Permutation([3, 2, 1, 0]))
+    assert P.rewrite(BlockDiagMatrix) == \
+        BlockDiagMatrix(P0, P3210, P0)
+
+    P = PermutationMatrix(Permutation([0, 4, 2, 3, 1, 5]))
+    P3120 = PermutationMatrix(Permutation([3, 1, 2, 0]))
+    assert P.rewrite(BlockDiagMatrix) == \
+        BlockDiagMatrix(P0, P3120, P0)
+
+    P = PermutationMatrix(Permutation(0, 3)(1, 4)(2, 5))
+    assert P.rewrite(BlockDiagMatrix) == BlockDiagMatrix(P)
+
+
+def test_MartrixPermute_basic():
+    p = Permutation(0, 1)
+    P = PermutationMatrix(p)
+    A = MatrixSymbol('A', 2, 2)
+
+    raises(ValueError, lambda: MatrixPermute(Symbol('x'), p))
+    raises(ValueError, lambda: MatrixPermute(A, Symbol('x')))
+
+    assert MatrixPermute(A, P) == MatrixPermute(A, p)
+    raises(ValueError, lambda: MatrixPermute(A, p, 2))
+
+    pp = Permutation(0, 1, size=3)
+    assert MatrixPermute(A, pp) == MatrixPermute(A, p)
+    pp = Permutation(0, 1, 2)
+    raises(ValueError, lambda: MatrixPermute(A, pp))
+
+
+def test_MatrixPermute_shape():
+    p = Permutation(0, 1)
+    A = MatrixSymbol('A', 2, 3)
+    assert MatrixPermute(A, p).shape == (2, 3)
+
+
+def test_MatrixPermute_explicit():
+    p = Permutation(0, 1, 2)
+    A = MatrixSymbol('A', 3, 3)
+    AA = A.as_explicit()
+    assert MatrixPermute(A, p, 0).as_explicit() == \
+        AA.permute(p, orientation='rows')
+    assert MatrixPermute(A, p, 1).as_explicit() == \
+        AA.permute(p, orientation='cols')
+
+
+def test_MatrixPermute_rewrite_MatMul():
+    p = Permutation(0, 1, 2)
+    A = MatrixSymbol('A', 3, 3)
+
+    assert MatrixPermute(A, p, 0).rewrite(MatMul).as_explicit() == \
+        MatrixPermute(A, p, 0).as_explicit()
+    assert MatrixPermute(A, p, 1).rewrite(MatMul).as_explicit() == \
+        MatrixPermute(A, p, 1).as_explicit()
+
+
+def test_MatrixPermute_doit():
+    p = Permutation(0, 1, 2)
+    A = MatrixSymbol('A', 3, 3)
+    assert MatrixPermute(A, p).doit() == MatrixPermute(A, p)
+
+    p = Permutation(0, size=3)
+    A = MatrixSymbol('A', 3, 3)
+    assert MatrixPermute(A, p).doit().as_explicit() == \
+        MatrixPermute(A, p).as_explicit()
+
+    p = Permutation(0, 1, 2)
+    A = Identity(3)
+    assert MatrixPermute(A, p, 0).doit().as_explicit() == \
+        MatrixPermute(A, p, 0).as_explicit()
+    assert MatrixPermute(A, p, 1).doit().as_explicit() == \
+        MatrixPermute(A, p, 1).as_explicit()
+
+    A = ZeroMatrix(3, 3)
+    assert MatrixPermute(A, p).doit() == A
+    A = OneMatrix(3, 3)
+    assert MatrixPermute(A, p).doit() == A
+
+    A = MatrixSymbol('A', 4, 4)
+    p1 = Permutation(0, 1, 2, 3)
+    p2 = Permutation(0, 2, 3, 1)
+    expr = MatrixPermute(MatrixPermute(A, p1, 0), p2, 0)
+    assert expr.as_explicit() == expr.doit().as_explicit()
+    expr = MatrixPermute(MatrixPermute(A, p1, 1), p2, 1)
+    assert expr.as_explicit() == expr.doit().as_explicit()