introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
5.84 kB
import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Contraction.DomainContractions
namespace OAI
/-! Domain Solver. -/
section
open scoped BigOperators
namespace Saxl.Columns
def edgeOptions {rsT rsA rsB : List β„•}
(D : Domains rsT) (E : Domains rsA) (F : Domains rsB)
(c : Edge rsT rsA rsB) (flag : Finset (β„• Γ— β„• Γ— β„•)) : Finset (β„• Γ— β„• Γ— β„•) :=
flag.filter (fun v => (D.atValue c.1 v.1).vanished = false ∧
(E.atValue c.2.1 v.2.1).vanished = false ∧ (F.atValue c.2.2 v.2.2).vanished = false)
lemma domainContraction_cons_options {rsT rsA rsB : List β„•}
(D : Domains rsT) (E : Domains rsA) (F : Domains rsB)
(c : Edge rsT rsA rsB) (edges : List (Edge rsT rsA rsB))
(flag : Finset (β„• Γ— β„• Γ— β„•)) :
domainContraction D E F (c::edges) flag =
βˆ‘ v ∈ edgeOptions D E F c flag, domainContraction (D.atValue c.1 v.1)
(E.atValue c.2.1 v.2.1) (F.atValue c.2.2 v.2.2) edges flag := by
rw [domainContraction_cons, edgeOptions, Finset.sum_filter]
apply Finset.sum_congr rfl
intro v hv
split_ifs with h
Β· rfl
Β· apply domainContraction_zero
simpa only [Bool.or_eq_true, Bool.not_eq_false, not_and_or, or_assoc] using h
def bringBest {Ξ± : Type*} (score : Ξ± β†’ β„•) : List Ξ± β†’ List Ξ±
| [] => []
| c :: cs => match bringBest score cs with
| [] => [c]
| d :: ds => if score c ≀ score d then c :: d :: ds else d :: c :: ds
lemma bringBest_perm {Ξ± : Type*} (score : Ξ± β†’ β„•) (cs : List Ξ±) :
(bringBest score cs).Perm cs := by
induction cs with
| nil => exact List.Perm.refl _
| cons c cs ih =>
rw [bringBest]
cases he : bringBest score cs with
| nil =>
rw [he] at ih
exact List.Perm.cons c ih
| cons d ds =>
rw [he] at ih
simp only
split_ifs
Β· exact List.Perm.cons c ih
Β· exact (List.Perm.swap _ _ _).trans (List.Perm.cons c ih)
def orderEdges {rsT rsA rsB : List β„•}
(D : Domains rsT) (E : Domains rsA) (F : Domains rsB)
(edges : List (Edge rsT rsA rsB)) (flag : Finset (β„• Γ— β„• Γ— β„•)) : List (Edge rsT rsA rsB) :=
bringBest (fun c => (edgeOptions D E F c flag).card) edges
lemma orderEdges_perm {rsT rsA rsB : List β„•}
(D : Domains rsT) (E : Domains rsA) (F : Domains rsB)
(edges : List (Edge rsT rsA rsB)) (flag : Finset (β„• Γ— β„• Γ— β„•)) :
(orderEdges D E F edges flag).Perm edges := bringBest_perm _ _
def solveDomains {rsT rsA rsB : List β„•} : β„• β†’ Domains rsT β†’ Domains rsA β†’ Domains rsB β†’
List (Edge rsT rsA rsB) β†’ Finset (β„• Γ— β„• Γ— β„•) β†’ β„€
| fuel, D, E, F, edges, flag =>
if D.vanished || E.vanished || F.vanished then 0
else match orderEdges D E F edges flag with
| [] => D.mass * E.mass * F.mass
| c :: cs => match fuel with
| 0 => 0
| k+1 => βˆ‘ v ∈ edgeOptions D E F c flag,
solveDomains k (D.atValue c.1 v.1) (E.atValue c.2.1 v.2.1)
(F.atValue c.2.2 v.2.2) cs flag
theorem solveDomains_correct {rsT rsA rsB : List β„•} (fuel : β„•)
(D : Domains rsT) (E : Domains rsA) (F : Domains rsB)
(edges : List (Edge rsT rsA rsB)) (flag : Finset (β„• Γ— β„• Γ— β„•))
(h : edges.length ≀ fuel) :
solveDomains fuel D E F edges flag = domainContraction D E F edges flag := by
induction fuel generalizing D E F edges with
| zero =>
have hh : orderEdges D E F edges flag = [] := by
apply List.length_eq_zero_iff.mp
rw [(orderEdges_perm D E F edges flag).length_eq]
omega
rw [solveDomains]
split_ifs with hv
Β· exact (domainContraction_zero D E F edges flag hv).symm
Β· rw [hh]
rw [← domainContraction_perm D E F (orderEdges_perm D E F edges flag) flag, hh]
exact (domainContraction_nil D E F flag).symm
| succ fuel ih =>
rw [solveDomains]
split_ifs with hv
Β· exact (domainContraction_zero D E F edges flag hv).symm
Β· have hp := orderEdges_perm D E F edges flag
rw [← domainContraction_perm D E F hp flag]
cases he : orderEdges D E F edges flag with
| nil => exact (domainContraction_nil D E F flag).symm
| cons c cs =>
have hlen : cs.length ≀ fuel := by
have hl := hp.length_eq
rw [he, List.length_cons] at hl
omega
rw [domainContraction_cons_options]
apply Finset.sum_congr rfl
intro v hv
exact ih _ _ _ _ hlen
def certificateEdges {n : β„•} (rsA rsB rsT : List β„•)
(ea : Fin n ≃ Fin rsA.sum) (eb : Fin n ≃ Fin rsB.sum) (et : Fin n ≃ Fin rsT.sum) :
List (Edge rsT rsA rsB) :=
List.ofFn (fun i => (enumerate rsT (et i), enumerate rsA (ea i), enumerate rsB (eb i)))
lemma contractionInteger_domains {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 (β„• Γ— β„• Γ— β„•)) :
contractionInteger rsA rsB rsT ea eb et (fun r a b => if (r,a,b) ∈ flag then 1 else 0) =
domainContraction (.full rsT) (.full rsA) (.full rsB)
(certificateEdges rsA rsB rsT ea eb et) flag := by
simp only [contractionInteger, domainContraction, Domains.full_weight,
certificateEdges, List.map_ofFn, List.prod_ofFn, Function.comp_apply]
theorem contractionInteger_solve {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 (β„• Γ— β„• Γ— β„•)) :
contractionInteger rsA rsB rsT ea eb et (fun r a b => if (r,a,b) ∈ flag then 1 else 0) =
solveDomains n (.full rsT) (.full rsA) (.full rsB)
(certificateEdges rsA rsB rsT ea eb et) flag := by
rw [solveDomains_correct n _ _ _ _ _ (by simp [certificateEdges])]
exact contractionInteger_domains ..
end Saxl.Columns
end
end OAI