import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.LabelOrder

namespace OAI

namespace MatchingFPRAS.Transport

open Finset

variable {V L J : Type*} [Fintype V] [DecidableEq V] [Fintype L] [DecidableEq L]
    [Fintype J] [DecidableEq J]

variable {b : V → Finset L} {c : V → Finset J}

def relabelEdge (e : L ≃ J) (h : ∀ v,(b v).image e=c v) (a : BagEdge b) : BagEdge c :=
  ⟨⟨(a.val.val.1,e a.val.val.2),a.val.property⟩,by
    intro v hv
    change e a.val.val.2∈c v
    rw [←h v]
    exact mem_image.mpr ⟨a.val.val.2,a.property v hv,rfl⟩⟩

omit [Fintype V] [DecidableEq V] [Fintype L] [Fintype J] in
lemma image_symm_bags (e : L ≃ J) (h : ∀ v,(b v).image e=c v) (v : V) :
    (c v).image e.symm=b v := by
  rw [←h v,image_image]
  simp

def relabelEdgeEquiv (e : L ≃ J) (h : ∀ v,(b v).image e=c v) : BagEdge b ≃ BagEdge c where
  toFun:=relabelEdge e h
  invFun:=relabelEdge e.symm (image_symm_bags e h)
  left_inv a := by apply Subtype.ext; apply Subtype.ext; simp [relabelEdge]
  right_inv a := by apply Subtype.ext; apply Subtype.ext; simp [relabelEdge]

omit [Fintype V] [DecidableEq V] [Fintype L] [Fintype J] in
lemma relabelEdge_incident (e : L ≃ J) (h : ∀ v,(b v).image e=c v) (a : BagEdge b) (v : V) :
    (relabelEdgeEquiv e h a).Incident v ↔ a.Incident v := Iff.rfl


variable {E F : Type*} [Fintype E] [DecidableEq E] [Fintype F] [DecidableEq F]

variable {inc : E → V → Prop} {j : F → V → Prop}

omit [Fintype V] [DecidableEq V] [Fintype E] [DecidableEq E] [Fintype F] in
lemma MatchingOn.image (e : E ≃ F) (he : ∀ a v,j (e a) v ↔ inc a v)
    {M : Finset E} {U : Finset V} (hM : MatchingOn inc M U) :
    MatchingOn j (M.image e) U := by
  constructor
  · intro f hf v hv
    obtain ⟨a,ha,rfl⟩:=mem_image.mp hf
    exact hM.1 a ha v ((he a v).mp hv)
  · intro v hv
    obtain ⟨a,⟨ha,hav⟩,hu⟩:=hM.2 v hv
    refine ⟨e a,⟨mem_image.mpr ⟨a,ha,rfl⟩,(he a v).mpr hav⟩,?_⟩
    rintro f ⟨hf,hfv⟩
    obtain ⟨d,hd,rfl⟩:=mem_image.mp hf
    exact congrArg e (hu d ⟨hd,(he d v).mp hfv⟩)

def pmEquiv (e : E ≃ F) (he : ∀ a v,j (e a) v ↔ inc a v) : PM inc ≃ PM j where
  toFun M:=⟨M.val.image e,M.property.image e he⟩
  invFun M:=⟨M.val.image e.symm,M.property.image e.symm (by intro a v; simpa using (he (e.symm a) v).symm)⟩
  left_inv M:=by apply Subtype.ext; simp [image_image]
  right_inv M:=by apply Subtype.ext; simp [image_image]

omit [DecidableEq V] [Fintype E] [Fintype F] in
lemma matchingWeight_pmEquiv [DecidableEq V] [Fintype E] [Fintype F]
    (e : E ≃ F) (he : ∀ a v,j (e a) v ↔ inc a v)
    (w : F → ℝ) (M : PM inc) : matchingWeight w (pmEquiv e he M)=matchingWeight (w ∘ e) M := by
  unfold matchingWeight pmEquiv
  exact Finset.prod_image (fun _ _ _ _ h=>e.injective h)

lemma partition_pmEquiv (e : E ≃ F) (he : ∀ a v,j (e a) v ↔ inc a v)
    (w : F → ℝ) : partition (inc:=j) w=partition (inc:=inc) (w ∘ e) := by
  classical
  unfold partition
  symm
  exact Finset.sum_equiv (pmEquiv e he) (by simp) (fun M _=>(matchingWeight_pmEquiv e he w M).symm)

lemma gibbs_pmEquiv (e : E ≃ F) (he : ∀ a v,j (e a) v ↔ inc a v)
    (w : F → ℝ) (M : PM inc) : gibbs w (pmEquiv e he M)=gibbs (w ∘ e) M := by
  unfold gibbs
  rw [matchingWeight_pmEquiv,partition_pmEquiv e he w]


end MatchingFPRAS.Transport

namespace MatchingFPRAS.RationalSource

open MatchingFPRAS Switching Subdivision RealGeometry Hierarchy Enlargement Transport Finset

variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V]

attribute [local instance] NumberedHierarchy.labelOrder sym2Order bagEdgeOrder bagEdgeFintype

attribute [local instance] UnitRefresh.Computable.allowedDec prodOrder sumOrder

noncomputable local instance {X : Type*} [Fintype X] (B : X → X → ℝ)
    (s : ∀ x y,B x y=B y x)
    (t : ∀ x y z,x≠y → x≠z → y≠z → min (B x z) (B z y)≤B x y) (H : ℕ) :
    DecidableEq (Hierarchy.Label B s t H) := Classical.decEq _

noncomputable def labelCast {X : Type*} [Fintype X] {B B' : X → X → ℝ}
    (s : ∀ x y,B x y=B y x)
    (t : ∀ x y z,x≠y → x≠z → y≠z → min (B x z) (B z y)≤B x y)
    (s' : ∀ x y,B' x y=B' y x)
    (t' : ∀ x y z,x≠y → x≠z → y≠z → min (B' x z) (B' z y)≤B' x y)
    {H H' : ℕ} (hB : B=B') (hH : H=H') :
    Hierarchy.Label B s t H ≃ Hierarchy.Label B' s' t' H' :=
  Equiv.cast (by cases hB;cases hH;rfl)

lemma labelCast_bags {X E : Type*} [Fintype X] [DecidableEq X] [Fintype E]
    {B B' : X → X → ℝ}
    (s : ∀ x y,B x y=B y x)
    (t : ∀ x y z,x≠y → x≠z → y≠z → min (B x z) (B z y)≤B x y)
    (s' : ∀ x y,B' x y=B' y x)
    (t' : ∀ x y z,x≠y → x≠z → y≠z → min (B' x z) (B' z y)≤B' x y)
    (u v : E → X) {H H' : ℕ} (hB : B=B') (hH : H=H') (x : X) :
    (memberships B s t u v H x).image (labelCast s t s' t' hB hH)=
      memberships B' s' t' u v H' x := by
  classical
  cases hB;cases hH
  simp [labelCast]

noncomputable def labelsEquiv (w : V → V → ℚ) (K : ℕ) :
    SourceLabel (fun x y=>(w x y:ℝ)) K ≃ Label w K :=
  (labelCast (sourceRealB_comm _ _) (sourceRealB_tri _ _)
    (NumberedHierarchy.symmetric (realB w K) (realB_symm w K))
    (NumberedHierarchy.triangular (realB w K) (realB_tri w K))
    (by funext x y;exact (realB_cast w K x y).symm) (levels_eq w K).symm).trans
      (NumberedHierarchy.labelEquiv (realB w K) (realB_symm w K) (realB_tri w K) (levels w K))

lemma source_bags_equiv (w : V → V → ℚ) (K : ℕ) (x : SourceVertex V K) :
    (sourceBags (fun a b=>(w a b:ℝ)) K x).image (labelsEquiv w K)=bags w K x := by
  change image ((NumberedHierarchy.labelEquiv _ _ _ _) ∘ _ ) _=_
  rw [←image_image,sourceBags,labelCast_bags]
  exact NumberedHierarchy.bags_equiv (realB w K) (realB_symm w K) (realB_tri w K)
    (realLeft K) (realRight K) (levels w K) x

end MatchingFPRAS.RationalSource

end OAI