import Mathlib
import OAI.SetTheory.PartitionConsistency.Forcing.SymmetricChoice

namespace OAI

/-! ## Mixing -/

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w t
noncomputable section
variable {P : Type w} [Preorder P] {Γ : Type v} [Group Γ]
variable (S : SymmetricSystem.{u} P Γ)
variable {ι : Type t} [Small.{u} ι]

/-- Index the literal children of a small family, with no uniform bound on
the ranks of the family's members. -/
abbrev MixEntries (f : ι → S.Name) := Σ i, Edges (f i).raw

def mixTest (f : ι → S.Name) (a : ι → P) (i : S.MixEntries f) (p : P) : Prop :=
  p ≤ a i.1 ∧ S.atomic.MemF p ((f i.1).child i.2.property) (f i.1)

omit [Small.{u} ι] in
/-- Fixing the names and their activation conditions permutes every entry
of their union mixture, including all strengthenings of all activations. -/
theorem mixTest_permute (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i) :
    ∀ g ∈ H, ∀ (i : S.MixEntries f) p, S.mixTest f a i p →
      ∃ j : S.MixEntries f, (f j.1).child j.2.property = g • (f i.1).child i.2.property ∧
        S.mixTest f a j (S.move g p) := by
  intro g hg i p hp
  have he := S.entry_permute g (f i.1) i.2
  rw [hf g hg i.1] at he
  obtain ⟨j,hj⟩ := he
  refine ⟨⟨i.1,j⟩,hj,?_,?_⟩
  · change S.move g p ≤ a i.1
    rw [← ha g hg i.1]
    exact (S.move g).monotone hp.1
  · change S.atomic.MemF (S.move g p) ((f i.1).child j.property) (f i.1)
    rw [hj]
    simpa only [hf g hg i.1] using (S.mem_symmetry g p _ (f i.1)).mp hp.2

/-- A coherent or antichain mixture. Coherence is a property proved separately;
the present construction itself is just the unrestricted union of active names. -/
def mix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i) : S.Name :=
  S.collect (fun i : S.MixEntries f => (f i.1).child i.2.property)
    (S.mixTest f a) H hH (S.mixTest_permute f a H hf ha)

theorem mix_fixed (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i) (g : Γ) (hg : g ∈ H) :
    g • S.mix f a H hH hf ha = S.mix f a H hH hf ha :=
  Subtype.ext (S.collectName_fixed _ _ H (S.mixTest_permute f a H hf ha) g hg)

theorem edge_mix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i) (ν : S.Name) (p : P) :
    ZFSet.pair ν.raw (S.code p) ∈ (S.mix f a H hH hf ha).raw ↔
      ∃ i : S.MixEntries f, (f i.1).child i.2.property = ν ∧ S.mixTest f a i p := by
  change ZFSet.pair ν.raw (S.code p) ∈
    S.collectRaw (fun i : S.MixEntries f => (f i.1).child i.2.property) (S.mixTest f a) ↔ _
  rw [S.edge_collectRaw]
  constructor
  · rintro ⟨i,c,hi,hν,hc⟩
    obtain rfl := S.code_injective hc
    exact ⟨i,Name.ext hν,hi⟩
  · rintro ⟨i,hi,hR⟩
    exact ⟨i,p,hR,congrArg Name.raw hi,rfl⟩

/-- The exact regular forcing value of membership in the union mixture. -/
theorem mem_mix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i) (ν : S.Name) (p : P) :
    S.atomic.MemF p ν (S.mix f a H hH hf ha) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i : ι, r ≤ a i ∧ S.atomic.MemF r ν (f i) := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,τ,c,he,hrc,heq⟩ := S.mem_iff.mp h q hqp
    obtain ⟨i,hi,hia,hit⟩ := (S.edge_mix f a H hH hf ha τ c).mp he
    change S.atomic.MemF c ((f i.1).child i.2.property) (f i.1) at hit
    rw [hi] at hit
    exact ⟨r,hrq,i.1,hrc.trans hia,
      (S.atomic.mem_congr heq (S.atomic.eq_refl r (f i.1))).mpr (S.atomic.mem_mono hrc hit)⟩
  · intro h
    apply S.mem_iff.mpr
    intro q hqp
    obtain ⟨r,hrq,i,hria,hν⟩ := h q hqp
    obtain ⟨s,hsr,τ,c,he,hsc,heq⟩ := S.mem_iff.mp hν r le_rfl
    let j : S.MixEntries f := ⟨i,⟨(τ.raw,S.code c),he⟩⟩
    have hj : (f j.1).child j.2.property = τ := Name.ext rfl
    have ht : S.mixTest f a j s := by
      change s ≤ a i ∧ S.atomic.MemF s ((f i).child he) (f i)
      exact ⟨hsr.trans hria,S.mem_of_edge he hsc⟩
    exact ⟨s,hsr.trans hrq,τ,s,(S.edge_mix f a H hH hf ha τ s).mpr ⟨j,hj,ht⟩,le_rfl,heq⟩

/-- Any coherent family is equal to its mixture below its activation
condition. This applies in particular to antichains, when coherence is vacuous. -/
theorem eq_mix_at (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hf : ∀ g ∈ H, ∀ i, g • f i = f i)
    (ha : ∀ g ∈ H, ∀ i, S.move g (a i) = a i)
    (hcoh : ∀ i j p, p ≤ a i → p ≤ a j → S.atomic.EqF p (f i) (f j)) (i : ι) :
    S.atomic.EqF (a i) (S.mix f a H hH hf ha) (f i) := by
  apply S.eq_of_same_members
  intro ν q hqi
  constructor
  · intro h
    apply S.atomic_regular.2 q ν (f i)
    intro r hrq
    obtain ⟨s,hsr,j,hsj,hm⟩ := (S.mem_mix f a H hH hf ha ν q).mp h r hrq
    exact ⟨s,hsr,(S.atomic.mem_congr (S.atomic.eq_refl s ν)
      (hcoh j i s hsj (hsr.trans (hrq.trans hqi)))).mp hm⟩
  · intro h
    apply (S.mem_mix f a H hH hf ha ν q).mpr
    intro r hrq
    exact ⟨r,le_rfl,i,hrq.trans hqi,S.atomic.mem_mono hrq h⟩

end
end PartitionConsistency.SetForcingNames.SymmetricSystem


/-! ## EquivariantMix -/

namespace PartitionConsistency.SetForcingNames.SymmetricSystem
universe u v w t
noncomputable section
variable {P : Type w} [Preorder P] {Γ : Type v} [Group Γ]
variable (S : SymmetricSystem.{u} P Γ)
variable {ι : Type t} [Small.{u} ι]

omit [Small.{u} ι] in
/-- An equivariant family need not have each member fixed pointwise.
Permuting the names together with their activation conditions suffices. -/
theorem equivariantMixTest_permute (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i)) :
    ∀ g ∈ H, ∀ (i : S.MixEntries f) p, S.mixTest f a i p →
      ∃ j : S.MixEntries f, (f j.1).child j.2.property = g • (f i.1).child i.2.property ∧
        S.mixTest f a j (S.move g p) := by
  intro g hg i p hp
  obtain ⟨j,hfj,haj⟩ := hperm g hg i.1
  have he := S.entry_permute g (f i.1) i.2
  rw [← hfj] at he
  obtain ⟨k,hk⟩ := he
  refine ⟨⟨j,k⟩,hk,?_,?_⟩
  · change S.move g p ≤ a j
    rw [haj]
    exact (S.move g).monotone hp.1
  · change S.atomic.MemF (S.move g p) ((f j).child k.property) (f j)
    rw [hk,hfj]
    exact (S.mem_symmetry g p _ (f i.1)).mp hp.2

/-- Union of an equivariant family of active arbitrary-rank names.
No choice of a common strengthening occurs in the definition. -/
def equivariantMix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i)) : S.Name :=
  S.collect (fun i : S.MixEntries f => (f i.1).child i.2.property)
    (S.mixTest f a) H hH (S.equivariantMixTest_permute f a H hperm)

theorem equivariantMix_fixed (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i)) (g : Γ) (hg : g ∈ H) :
    g • S.equivariantMix f a H hH hperm = S.equivariantMix f a H hH hperm :=
  Subtype.ext (S.collectName_fixed _ _ H (S.equivariantMixTest_permute f a H hperm) g hg)

theorem edge_equivariantMix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i)) (ν : S.Name) (p : P) :
    ZFSet.pair ν.raw (S.code p) ∈ (S.equivariantMix f a H hH hperm).raw ↔
      ∃ i : S.MixEntries f, (f i.1).child i.2.property = ν ∧ S.mixTest f a i p := by
  change ZFSet.pair ν.raw (S.code p) ∈
    S.collectRaw (fun i : S.MixEntries f => (f i.1).child i.2.property) (S.mixTest f a) ↔ _
  rw [S.edge_collectRaw]
  constructor
  · rintro ⟨i,c,hi,hν,hc⟩
    obtain rfl := S.code_injective hc
    exact ⟨i,Name.ext hν,hi⟩
  · rintro ⟨i,hi,hR⟩
    exact ⟨i,p,hR,congrArg Name.raw hi,rfl⟩

/-- The exact regular forcing value of membership in the union mixture. -/
theorem mem_equivariantMix (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i)) (ν : S.Name) (p : P) :
    S.atomic.MemF p ν (S.equivariantMix f a H hH hperm) ↔
      ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ i : ι, r ≤ a i ∧ S.atomic.MemF r ν (f i) := by
  constructor
  · intro h q hqp
    obtain ⟨r,hrq,τ,c,he,hrc,heq⟩ := S.mem_iff.mp h q hqp
    obtain ⟨i,hi,hia,hit⟩ := (S.edge_equivariantMix f a H hH hperm τ c).mp he
    change S.atomic.MemF c ((f i.1).child i.2.property) (f i.1) at hit
    rw [hi] at hit
    exact ⟨r,hrq,i.1,hrc.trans hia,
      (S.atomic.mem_congr heq (S.atomic.eq_refl r (f i.1))).mpr (S.atomic.mem_mono hrc hit)⟩
  · intro h
    apply S.mem_iff.mpr
    intro q hqp
    obtain ⟨r,hrq,i,hria,hν⟩ := h q hqp
    obtain ⟨s,hsr,τ,c,he,hsc,heq⟩ := S.mem_iff.mp hν r le_rfl
    let j : S.MixEntries f := ⟨i,⟨(τ.raw,S.code c),he⟩⟩
    have hj : (f j.1).child j.2.property = τ := Name.ext rfl
    have ht : S.mixTest f a j s := by
      change s ≤ a i ∧ S.atomic.MemF s ((f i).child he) (f i)
      exact ⟨hsr.trans hria,S.mem_of_edge he hsc⟩
    exact ⟨s,hsr.trans hrq,τ,s,(S.edge_equivariantMix f a H hH hperm τ s).mpr ⟨j,hj,ht⟩,le_rfl,heq⟩

/-- Any coherent family is equal to its mixture below its activation
condition. This applies in particular to antichains, when coherence is vacuous. -/
theorem eq_equivariantMix_at (f : ι → S.Name) (a : ι → P) (H : Subgroup Γ) (hH : H ∈ S.filter)
    (hperm : ∀ g ∈ H, ∀ i, ∃ j, f j = g • f i ∧ a j = S.move g (a i))
    (hcoh : ∀ i j p, p ≤ a i → p ≤ a j → S.atomic.EqF p (f i) (f j)) (i : ι) :
    S.atomic.EqF (a i) (S.equivariantMix f a H hH hperm) (f i) := by
  apply S.eq_of_same_members
  intro ν q hqi
  constructor
  · intro h
    apply S.atomic_regular.2 q ν (f i)
    intro r hrq
    obtain ⟨s,hsr,j,hsj,hm⟩ := (S.mem_equivariantMix f a H hH hperm ν q).mp h r hrq
    exact ⟨s,hsr,(S.atomic.mem_congr (S.atomic.eq_refl s ν)
      (hcoh j i s hsj (hsr.trans (hrq.trans hqi)))).mp hm⟩
  · intro h
    apply (S.mem_equivariantMix f a H hH hperm ν q).mpr
    intro r hrq
    exact ⟨r,le_rfl,i,hrq.trans hqi,S.atomic.mem_mono hrq h⟩

end
end PartitionConsistency.SetForcingNames.SymmetricSystem

end OAI