| import Mathlib |
| import OAI.Probability.SKGap.Localization.Append |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| noncomputable section |
| noncomputable section |
| open scoped BigOperators |
| namespace SKGap.Noncrossing |
| namespace InverseDiagram |
|
|
| def blockDegree (bs : List Bool) : ℕ := (bs.map (fun b => if b then 1 else 2)).sum |
|
|
| def blockEnumerate : ℕ → List (List Bool) |
| | 0 => [[]] |
| | n+1 => (blockEnumerate n).map (true::·) ++ |
| (if n=0 then [] else (blockEnumerate (n-1)).map (false::·)) |
| termination_by m => m |
|
|
| def Blocks (n : ℕ) := {bs : List Bool // blockDegree bs=n} |
|
|
| @[simp] lemma blockDegree_nil : blockDegree []=0 := rfl |
| @[simp] lemma blockDegree_true (bs : List Bool) : |
| blockDegree (true::bs)=blockDegree bs+1 := by simp [blockDegree,add_comm] |
| @[simp] lemma blockDegree_false (bs : List Bool) : |
| blockDegree (false::bs)=blockDegree bs+2 := by simp [blockDegree,add_comm] |
|
|
| lemma mem_blockEnumerate (bs : List Bool) (n : ℕ) : |
| bs∈blockEnumerate n ↔ blockDegree bs=n := by |
| induction n using Nat.strong_induction_on generalizing bs with |
| | h n ih => |
| cases n with |
| | zero => |
| cases bs with |
| | nil => simp [blockEnumerate] |
| | cons b bs => cases b <;> simp [blockEnumerate] |
| | succ n => |
| rw [blockEnumerate] |
| cases bs with |
| | nil => split_ifs <;> simp |
| | cons b bs => |
| cases b with |
| | true => |
| have ht : ((true::bs)∈(blockEnumerate n).map (true::·) ++ |
| (if n=0 then [] else (blockEnumerate (n-1)).map (false::·))) ↔ |
| bs∈blockEnumerate n := by split_ifs <;> simp |
| rw [ht,ih n (by omega) bs,blockDegree_true] |
| omega |
| | false => |
| by_cases hn : n=0 |
| · subst n; simp |
| · have hf : ((false::bs)∈(blockEnumerate n).map (true::·) ++ |
| (if n=0 then [] else (blockEnumerate (n-1)).map (false::·))) ↔ |
| bs∈blockEnumerate (n-1) := by simp [hn] |
| rw [hf,ih (n-1) (by omega) bs,blockDegree_false] |
| omega |
|
|
| lemma blockEnumerate_nodup (n : ℕ) : (blockEnumerate n).Nodup := by |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| cases n with |
| | zero => simp [blockEnumerate] |
| | succ n => |
| rw [blockEnumerate,List.nodup_append] |
| refine ⟨(List.nodup_map_iff (by intro a b h; exact List.cons.inj h |>.2)).mpr |
| (ih n (by omega)),?_,?_⟩ |
| · split_ifs |
| · simp |
| · exact (List.nodup_map_iff (by intro a b h; exact List.cons.inj h |>.2)).mpr |
| (ih (n-1) (by omega)) |
| · split_ifs |
| · simp |
| · intro bs h1 cs h2 he |
| obtain ⟨p,_,rfl⟩ := List.mem_map.mp h1 |
| obtain ⟨q,_,rfl⟩ := List.mem_map.mp h2 |
| cases he |
|
|
| instance blocksFintype (n : ℕ) : Fintype (Blocks n) := |
| Fintype.ofFinset (blockEnumerate n).toFinset (by |
| intro bs |
| simp only [List.mem_toFinset,mem_blockEnumerate]; rfl) |
|
|
| def LiteralPaired (n : ℕ) := Σ bs : Blocks n, Diagram.Paired (expandBlocks bs.val) |
| instance literalPairedFintype (n : ℕ) : Fintype (LiteralPaired n) := |
| inferInstanceAs (Fintype (Σ bs : Blocks n, Diagram.Paired (expandBlocks bs.val))) |
|
|
| def AtDegree (n : ℕ) := {d : InverseDiagram // d.degree=n} |
| instance atDegreeFintype (n : ℕ) : Fintype (AtDegree n) := |
| Fintype.ofFinset (enumerate n).toFinset (by |
| intro d |
| simp only [List.mem_toFinset,mem_enumerate]; rfl) |
|
|
| def toLiteral {n : ℕ} (d : AtDegree n) : LiteralPaired (2*n) := |
| ⟨⟨d.val.blocks,by |
| simpa only [blockDegree,d.property] using d.val.blocks_degree⟩, |
| ⟨d.val.toDiagram,d.val.toDiagram_word⟩⟩ |
|
|
| lemma toLiteral_bijective (n : ℕ) : Function.Bijective (@toLiteral n) := by |
| constructor |
| · intro d e he |
| apply Subtype.ext |
| apply toDiagram_injective |
| exact congrArg (fun z : LiteralPaired (2*n) => z.2.val) he |
| · intro z |
| obtain ⟨e,he,hed⟩ := toDiagram_surjective z.2.val z.1.val z.2.property |
| have hn : e.degree=n := by |
| have hh := e.blocks_degree |
| rw [he] at hh |
| change blockDegree z.1.val=2*e.degree at hh |
| rw [z.1.property] at hh |
| omega |
| use ⟨e,hn⟩ |
| apply Sigma.ext |
| · exact Subtype.ext he |
| · apply (Subtype.heq_iff_coe_eq (fun d => ?_)).mpr hed |
| change d.word=expandBlocks e.blocks ↔ d.word=expandBlocks z.1.val |
| rw [he] |
|
|
| def literalEquiv (n : ℕ) : AtDegree n ≃ LiteralPaired (2*n) := |
| Equiv.ofBijective toLiteral (toLiteral_bijective n) |
|
|
| lemma literal_odd_empty (n : ℕ) : IsEmpty (LiteralPaired (2*n+1)) := by |
| constructor |
| intro z |
| obtain ⟨e,he,hed⟩ := toDiagram_surjective z.2.val z.1.val z.2.property |
| have hh := e.blocks_degree |
| rw [he] at hh |
| change blockDegree z.1.val=2*e.degree at hh |
| rw [z.1.property] at hh |
| omega |
|
|
| variable {ι : Type*} [Fintype ι] |
|
|
| def blockLabel (j : ℝ) (a : ι→ℝ) : Bool → ι→ℝ |
| | true => a |
| | false => fun i => -(j*average a)*a i |
|
|
| lemma toDiagram_value (j : ℝ) (a : ι→ℝ) (d : InverseDiagram) (i : ι) : |
| (d.toDiagram.map (blockLabel j a)).value j i = d.value j a i := by |
| induction d generalizing i with |
| | empty => rfl |
| | counterterm d ih => simp [toDiagram,Diagram.map,Diagram.value,blockLabel,value,ih] |
| | arch u v iu iv => |
| simp only [toDiagram,Diagram.map,Diagram.map_append,Diagram.value,blockLabel, |
| value,iv] |
| have hm : Diagram.mean (fun k => (u.toDiagram.map (blockLabel j a)).value j k*a k) = |
| average (fun k => a k*value j a u k) := by |
| simp only [Diagram.mean,average] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro k _ |
| rw [iu] |
| ring |
| have hv : Diagram.value j ((u.toDiagram.map (blockLabel j a)).append (.diag a .nil)) = |
| (fun k => (u.toDiagram.map (blockLabel j a)).value j k * a k) := by |
| funext k |
| simp only [Diagram.value_append,Diagram.value,mul_one] |
| rw [hv,hm] |
| ring |
|
|
| def literalCoefficient (j : ℝ) (a : ι→ℝ) (n : ℕ) (i : ι) : ℝ := |
| ∑ z : LiteralPaired n, (z.2.val.map (blockLabel j a)).value j i |
|
|
| lemma literalCoefficient_even (j : ℝ) (a : ι→ℝ) (n : ℕ) (i : ι) : |
| literalCoefficient j a (2*n) i=coefficient j a n i := by |
| have hh := Fintype.sum_equiv (literalEquiv n) |
| (fun d => value j a d.val i) |
| (fun z => (z.2.val.map (blockLabel j a)).value j i) |
| (fun d => (toDiagram_value j a d.val i).symm) |
| change _=literalCoefficient j a (2*n) i at hh |
| rw [← hh] |
| let : Fintype {d : InverseDiagram // d.degree=n} := atDegreeFintype n |
| change (∑ d : {d : InverseDiagram // d.degree=n}, value j a d.val i) = _ |
| have hx := Finset.sum_subtype (p := fun d : InverseDiagram => d.degree=n) |
| (F := atDegreeFintype n) |
| (enumerate n).toFinset (by |
| intro d; simpa only [List.mem_toFinset] using mem_enumerate d n) |
| (fun d => value j a d i) |
| exact hx.symm.trans (List.sum_toFinset _ (enumerate_nodup n)) |
|
|
| lemma literalCoefficient_odd (j : ℝ) (a : ι→ℝ) (n : ℕ) (i : ι) : |
| literalCoefficient j a (2*n+1) i=0 := by |
| let := literal_odd_empty n |
| exact Finset.sum_eq_zero (by intro z; exact isEmptyElim z) |
|
|
| theorem literalCoefficient_eq (j : ℝ) (a : ι→ℝ) (n : ℕ) (i : ι) : |
| literalCoefficient j a n i = if n=0 then 1 else 0 := by |
| obtain ⟨m,hm⟩|⟨m,hm⟩ := Nat.even_or_odd n |
| · have he : n=2*m := by omega |
| rw [he,literalCoefficient_even] |
| by_cases h : m=0 |
| · subst m; simp |
| · rw [coefficient_positive j a m (by omega)] |
| simp [h] |
| · have he : n=2*m+1 := by omega |
| rw [he,literalCoefficient_odd] |
| simp |
|
|
| end InverseDiagram |
| end SKGap.Noncrossing |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
