openAI-math-dataset / lean /OAI /RepresentationTheory /UniversalSquare /Contraction /ChoiceContractions.lean
| import Mathlib | |
| import OAI.RepresentationTheory.Saxl.Main | |
| import OAI.RepresentationTheory.UniversalSquare.Support.RowSquareTools | |
| namespace OAI | |
| /-! Choice Contractions. -/ | |
| section | |
| open scoped BigOperators | |
| namespace Saxl.Columns | |
| inductive EdgeChoices where | |
| | fallback | |
| | node (index : ℕ) (next : (ℕ × ℕ × ℕ) → EdgeChoices) | |
| def solveChoices {rsT rsA rsB : List ℕ} : EdgeChoices → CompactDomains rsT → | |
| CompactDomains rsA → CompactDomains rsB → List (Edge rsT rsA rsB) → | |
| Finset (ℕ × ℕ × ℕ) → ℤ | |
| | .fallback, D, E, F, edges, flag => solveCompact edges.length D E F edges flag | |
| | .node i next, D, E, F, edges, flag => | |
| if D.vanished || E.vanished || F.vanished then 0 | |
| else match edges.rotate i with | |
| | [] => D.mass * E.mass * F.mass | |
| | c :: cs => ∑ v ∈ compactEdgeOptions D E F c flag, | |
| solveChoices (next v) (D.atValue c.1 v.1) (E.atValue c.2.1 v.2.1) | |
| (F.atValue c.2.2 v.2.2) cs flag | |
| lemma solveChoices_correct {rsT rsA rsB : List ℕ} (ch : EdgeChoices) | |
| (D : CompactDomains rsT) (E : CompactDomains rsA) (F : CompactDomains rsB) | |
| (edges : List (Edge rsT rsA rsB)) (flag : Finset (ℕ × ℕ × ℕ)) : | |
| solveChoices ch D E F edges flag = | |
| domainContraction D.describe E.describe F.describe edges flag := by | |
| induction ch generalizing D E F edges with | |
| | fallback => | |
| rw [solveChoices, ← solveCompact_describe] | |
| exact solveDomains_correct _ _ _ _ _ _ le_rfl | |
| | node i next ih => | |
| rw [solveChoices] | |
| split_ifs with hv | |
| · apply Eq.symm | |
| apply domainContraction_zero | |
| simpa only [CompactDomains.describe_vanished] using hv | |
| · rw [← domainContraction_perm D.describe E.describe F.describe (edges.rotate_perm i) flag] | |
| cases he : edges.rotate i with | |
| | nil => simp only [domainContraction_nil, CompactDomains.describe_mass] | |
| | cons c cs => | |
| rw [domainContraction_cons_options, compactEdgeOptions_describe] | |
| apply Finset.sum_congr rfl | |
| intro v hv | |
| rw [ih] | |
| simp only [CompactDomains.describe_atValue] | |
| lemma contractionInteger_choices {n : ℕ} (rsA rsB rsT : List ℕ) | |
| (ea : Fin n ≃ Fin rsA.sum) (eb : Fin n ≃ Fin rsB.sum) (et : Fin n ≃ Fin rsT.sum) | |
| (flag : Finset (ℕ × ℕ × ℕ)) (ch : EdgeChoices) : | |
| contractionInteger rsA rsB rsT ea eb et (fun r a b => if (r,a,b) ∈ flag then 1 else 0) = | |
| solveChoices ch (.full rsT) (.full rsA) (.full rsB) | |
| (certificateEdges rsA rsB rsT ea eb et) flag := by | |
| rw [solveChoices_correct, CompactDomains.describe_full, CompactDomains.describe_full, | |
| CompactDomains.describe_full] | |
| exact contractionInteger_domains .. | |
| end Saxl.Columns | |
| noncomputable section | |
| namespace UniversalTensorSquare | |
| open Saxl Saxl.Columns Saxl.Balance | |
| lemma rowSquare_choices {n : ℕ} {p q cs ts : List ℕ} | |
| (hp : GoodRows p) (hq : GoodRows q) (hcs : GoodRows cs) (hts : GoodRows ts) | |
| (he : cs = transposeRows p ∨ cs = p) (ht : ts = transposeRows q) | |
| (hn : cs.sum = n) (hn' : ts.sum = n) | |
| (eb : Fin n ≃ Fin cs.sum) (et : Fin n ≃ Fin ts.sum) | |
| (flag : Finset (ℕ × ℕ × ℕ)) (ch : EdgeChoices) | |
| (hcert : solveChoices ch (.full ts) (.full cs) (.full cs) | |
| (certificateEdges cs cs ts (finCongr hn.symm) eb et) flag ≠ 0) : RowSquare p q := by | |
| apply rowSquare_domain hp hq hcs hts he ht hn hn' eb et flag | |
| rw [← contractionInteger_solve, contractionInteger_choices _ _ _ _ _ _ flag ch] | |
| exact hcert | |
| end UniversalTensorSquare | |
| end | |
| end | |
| end OAI | |