| import Mathlib |
| import OAI.Analysis.FreeWords.CutAlgebra |
| import OAI.Analysis.FreeWords.TupleCombinatorics |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace KKFreeWords |
|
|
| open scoped BigOperators |
|
|
| noncomputable section |
|
|
| variable {R α : Type*} [Semiring R] [Fintype α] [DecidableEq α] |
|
|
| omit [Semiring R] in |
| theorem ofFn_take_add {m n : ℕ} (f : Fin (m+n) → R) : |
| (List.ofFn f).take m = List.ofFn (fun i => f (i.castAdd n)) := by |
| rw [List.ofFn_add] |
| have he : (fun i : Fin m => f (Fin.castLE (Nat.le_add_right m n) i)) = |
| (fun i : Fin m => f (i.castAdd n)) := by |
| funext i |
| congr 1 |
| rw [he] |
| simpa only [List.length_ofFn] using |
| (List.take_left (l₁ := List.ofFn (fun i : Fin m => f (i.castAdd n))) |
| (l₂ := List.ofFn (fun i : Fin n => f (Fin.natAdd m i)))) |
|
|
| omit [Semiring R] in |
| theorem ofFn_drop_add {m n : ℕ} (f : Fin (m+n) → R) : |
| (List.ofFn f).drop m = List.ofFn (fun i => f (Fin.natAdd m i)) := by |
| rw [List.ofFn_add] |
| have he : (fun i : Fin m => f (Fin.castLE (Nat.le_add_right m n) i)) = |
| (fun i : Fin m => f (i.castAdd n)) := by |
| funext i |
| congr 1 |
| rw [he] |
| simpa only [List.length_ofFn] using |
| (List.drop_left (l₁ := List.ofFn (fun i : Fin m => f (i.castAdd n))) |
| (l₂ := List.ofFn (fun i : Fin n => f (Fin.natAdd m i)))) |
|
|
| omit [Fintype α] [DecidableEq α] in |
| theorem tupleLabels_append {m n : ℕ} (a : Fin m → α) (b : Fin n → α) : |
| tupleLabels (Fin.append a b) = tupleLabels a + tupleLabels b := by |
| simp only [tupleLabels, List.ofFn_fin_append, Multiset.coe_add] |
|
|
| def tupleProduct {n : ℕ} (C : Fin n → α → R) (a : Fin n → α) : R := |
| (List.ofFn (fun j => C j (a j))).prod |
|
|
| theorem sum_noPresCut (p q : ℕ) (W : Multiset α) |
| (C D : Fin (q+p) → α → R) : |
| (∑ a : Fin (q+p) → α, if tupleLabels a = W then |
| noPresCut (fun j => C j (a j)) (fun j => D j (a j)) q else 0) = |
| ∑ a : Fin q → α, ∑ b : Fin p → α, |
| tupleProduct (fun j => C (j.castAdd p)) a * |
| (if tupleLabels a + tupleLabels b = W then 1 else 0) * |
| tupleProduct (fun j => D (Fin.natAdd q j)) b := by |
| rw [← Equiv.sum_comp (Fin.appendEquiv q p)] |
| simp only [Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl |
| intro a ha |
| apply Finset.sum_congr rfl |
| intro b hb |
| change (if tupleLabels (Fin.append a b) = W then |
| noPresCut (fun j => C j ((Fin.append a b) j)) |
| (fun j => D j ((Fin.append a b) j)) q else 0) = _ |
| simp only [tupleLabels_append, noPresCut, |
| ofFn_take_add, ofFn_drop_add, Fin.append_left, Fin.append_right, tupleProduct] |
| split_ifs <;> simp |
|
|
| theorem sum_presCut (p q : ℕ) (W : Multiset α) |
| (C D K : Fin (q+(p+1)) → α → R) : |
| (∑ a : Fin (q+(p+1)) → α, if tupleLabels a = W then |
| presCut (fun j => C j (a j)) (fun j => D j (a j)) (fun j => K j (a j)) |
| (Fin.natAdd q 0) else 0) = |
| ∑ a : Fin q → α, ∑ b : Fin p → α, |
| tupleProduct (fun j => C (j.castAdd (p+1))) a * |
| (∑ c : α, if tupleLabels a + {c} + tupleLabels b = W then |
| K (Fin.natAdd q 0) c else 0) * |
| tupleProduct (fun j => D (Fin.natAdd q j.succ)) b := by |
| rw [← Equiv.sum_comp (Fin.appendEquiv q (p+1))] |
| simp only [Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl |
| intro a ha |
| rw [← Equiv.sum_comp (Fin.consEquiv (fun _ : Fin (p+1) => α))] |
| simp only [Fintype.sum_prod_type] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro b hb |
| rw [Finset.mul_sum, Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro c hc |
| change (if tupleLabels (Fin.append a (Fin.cons c b)) = W then |
| presCut (fun j => C j ((Fin.append a (Fin.cons c b)) j)) |
| (fun j => D j ((Fin.append a (Fin.cons c b)) j)) |
| (fun j => K j ((Fin.append a (Fin.cons c b)) j)) (Fin.natAdd q 0) else 0) = _ |
| have he : presCut (fun j => C j ((Fin.append a (Fin.cons c b)) j)) |
| (fun j => D j ((Fin.append a (Fin.cons c b)) j)) |
| (fun j => K j ((Fin.append a (Fin.cons c b)) j)) (Fin.natAdd q 0) = |
| tupleProduct (fun j => C (j.castAdd (p+1))) a * K (Fin.natAdd q 0) c * |
| tupleProduct (fun j => D (Fin.natAdd q j.succ)) b := by |
| dsimp only [presCut] |
| rw [Fin.append_right, Fin.cons_zero] |
| change ((List.ofFn (fun j => C j ((Fin.append a (Fin.cons c b)) j))).take q).prod * |
| K (Fin.natAdd q 0) c * |
| ((List.ofFn (fun j => D j ((Fin.append a (Fin.cons c b)) j))).drop (q+1)).prod = _ |
| have hd : (List.ofFn (fun j => D j ((Fin.append a (Fin.cons c b)) j))).drop (q+1) = |
| List.ofFn (fun j => D (Fin.natAdd q j.succ) (b j)) := by |
| rw [← List.drop_drop, ofFn_drop_add, List.ofFn_succ] |
| simp only [Fin.append_right, List.drop_succ_cons, List.drop_zero, Fin.cons_succ] |
| rw [hd, ofFn_take_add] |
| simp only [Fin.append_left, tupleProduct] |
| rw [he, tupleLabels_append, tupleLabels_cons, ← add_assoc] |
| split_ifs <;> simp |
|
|
| end |
|
|
| end KKFreeWords |
| end |
|
|
| end OAI |
|
|
