lean/OAI/Computability/LoopMatching/ExpandBijection.lean

import OAI.Computability.LoopMatching.ChoiceCounts

namespace OAI

/-! Polynomial-time approximation of weighted matchings with singleton loops. -/

noncomputable section
open scoped BigOperators
namespace LoopMatching

def SupportedMatching (G : Input) (j : ℕ) :=
  {N : (BinaryMatching.completeGraph (expand G j).n).Matching //
    ∀ e ∈ N.val, e.val.1.val < G.n}

def oldVertex (G : Input) (j : ℕ) (v : Fin G.n) : Fin (expand G j).n :=
  ⟨v.val, by have := v.isLt; simp only [expand_n]; omega⟩

def dummyVertex (G : Input) (j : ℕ) (d : Fin j) : Fin (expand G j).n :=
  ⟨G.n + d.val, by have := d.isLt; simp only [expand_n]; omega⟩

@[simp] lemma incident_oldPair (G : Input) (j : ℕ) (v : Fin G.n)
    (e : BinaryMatching.Pair G.n) :
    (BinaryMatching.completeGraph (expand G j).n).Incident
      (oldVertex G j v) (oldPair G j e) ↔
    (BinaryMatching.completeGraph G.n).Incident v e := by
  simp [MatchingEntropy.LooplessGraph.Incident, BinaryMatching.completeGraph,
    oldVertex, oldPair, Fin.ext_iff]

lemma oldPair_injective (G : Input) (j : ℕ) : Function.Injective (oldPair G j) := by
  intro e f h
  apply Subtype.ext
  apply Prod.ext <;> apply Fin.ext
  · exact congrArg (fun p => p.val.1.val) h
  · exact congrArg (fun p => p.val.2.val) h

lemma crossPair_injective (G : Input) (j : ℕ) {v w : Fin G.n} {d c : Fin j}
    (h : crossPair G j v d = crossPair G j w c) : v = w ∧ d = c := by
  constructor
  · apply Fin.ext
    exact congrArg (fun p => p.val.1.val) h
  · apply Fin.ext
    have hh := congrArg (fun p => p.val.2.val) h
    dsimp [crossPair] at hh
    omega

lemma oldPair_ne_crossPair (G : Input) (j : ℕ) (e : BinaryMatching.Pair G.n)
    (v : Fin G.n) (d : Fin j) : oldPair G j e ≠ crossPair G j v d := by
  intro h
  have hh := congrArg (fun p => p.val.2.val) h
  have he := e.val.2.isLt
  dsimp [oldPair, crossPair] at hh
  omega

lemma matching_edge_unique (G : Input) (j : ℕ)
    (N : (BinaryMatching.completeGraph (expand G j).n).Matching)
    (v : Fin (expand G j).n) (e f : BinaryMatching.Pair (expand G j).n)
    (he : e ∈ N.val) (hf : f ∈ N.val)
    (hve : (BinaryMatching.completeGraph (expand G j).n).Incident v e)
    (hvf : (BinaryMatching.completeGraph (expand G j).n).Incident v f) : e = f := by
  obtain ⟨a, ha, hu⟩ := N.property v
  exact (hu e ⟨he,hve⟩).trans (hu f ⟨hf,hvf⟩).symm

def restrictMatching (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    PartialMatching G.n := by
  classical
  refine ⟨Finset.univ.filter (fun e => oldPair G j e ∈ N.val.val), ?_⟩
  intro v e he f hf hve hvf
  apply oldPair_injective G j
  exact matching_edge_unique G j N.val (oldVertex G j v) _ _
    (Finset.mem_filter.mp he).2 (Finset.mem_filter.mp hf).2
    ((incident_oldPair G j v e).mpr hve) ((incident_oldPair G j v f).mpr hvf)

@[simp] lemma mem_restrictMatching (G : Input) (j : ℕ) (N : SupportedMatching G j)
    (e : BinaryMatching.Pair G.n) :
    e ∈ (restrictMatching G j N).val ↔ oldPair G j e ∈ N.val.val := by
  simp [restrictMatching]

lemma exists_crossPartner (G : Input) (j : ℕ) (N : SupportedMatching G j)
    (d : Fin j) : ∃ v : Fin G.n, crossPair G j v d ∈ N.val.val := by
  obtain ⟨e,⟨he,hi⟩,hu⟩ := N.val.property (dummyVertex G j d)
  have hl := N.property e he
  have hr : e.val.2.val = G.n + d.val := by
    rcases hi with hi | hi
    · have hh := congrArg Fin.val hi
      dsimp [BinaryMatching.completeGraph, dummyVertex] at hh
      omega
    · exact congrArg Fin.val hi
  let v : Fin G.n := ⟨e.val.1.val,hl⟩
  refine ⟨v, ?_⟩
  have hh : crossPair G j v d = e := by
    apply Subtype.ext
    apply Prod.ext <;> apply Fin.ext
    · rfl
    · exact hr.symm
  simpa only [hh] using he

def crossPartner (G : Input) (j : ℕ) (N : SupportedMatching G j) (d : Fin j) : Fin G.n :=
  Classical.choose (exists_crossPartner G j N d)

lemma crossPartner_mem (G : Input) (j : ℕ) (N : SupportedMatching G j) (d : Fin j) :
    crossPair G j (crossPartner G j N d) d ∈ N.val.val :=
  Classical.choose_spec (exists_crossPartner G j N d)

lemma crossPartner_eq (G : Input) (j : ℕ) (N : SupportedMatching G j)
    (v : Fin G.n) (d : Fin j) (hv : crossPair G j v d ∈ N.val.val) :
    crossPartner G j N d = v := by
  have he := matching_edge_unique G j N.val (dummyVertex G j d) _ _
    (crossPartner_mem G j N d) hv (Or.inr rfl) (Or.inr rfl)
  exact (crossPair_injective G j he).1

lemma crossPartner_uncovered (G : Input) (j : ℕ) (N : SupportedMatching G j) (d : Fin j) :
    crossPartner G j N d ∈ loopVertices (restrictMatching G j N) := by
  classical
  apply Finset.mem_filter.mpr
  refine ⟨Finset.mem_univ _, ?_⟩
  intro e he hi
  apply oldPair_ne_crossPair G j e (crossPartner G j N d) d
  exact matching_edge_unique G j N.val (oldVertex G j (crossPartner G j N d)) _ _
    ((mem_restrictMatching G j N e).mp he) (crossPartner_mem G j N d)
    ((incident_oldPair G j _ e).mpr hi) (Or.inl rfl)

lemma crossPartner_injective (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    Function.Injective (crossPartner G j N) := by
  intro d c h
  have he := matching_edge_unique G j N.val (oldVertex G j (crossPartner G j N d))
    _ _ (crossPartner_mem G j N d) (crossPartner_mem G j N c)
    (Or.inl rfl) (Or.inl (congrArg (oldVertex G j) h.symm))
  exact (crossPair_injective G j he).2

lemma crossPartner_surjective (G : Input) (j : ℕ) (N : SupportedMatching G j)
    (v : loopVertices (restrictMatching G j N)) :
    ∃ d : Fin j, crossPartner G j N d = v.val := by
  classical
  obtain ⟨e,⟨he,hi⟩,hu⟩ := N.val.property (oldVertex G j v.val)
  have hl := N.property e he
  have hr : G.n ≤ e.val.2.val := by
    by_contra hh
    have hright : e.val.2.val < G.n := by omega
    let f : BinaryMatching.Pair G.n :=
      ⟨(⟨e.val.1.val,hl⟩,⟨e.val.2.val,hright⟩), e.property⟩
    have hef : oldPair G j f = e := by
      apply Subtype.ext
      apply Prod.ext <;> apply Fin.ext <;> rfl
    have hf : f ∈ (restrictMatching G j N).val := by
      rw [mem_restrictMatching, hef]
      exact he
    have huv := (Finset.mem_filter.mp v.property).2
    apply huv f hf
    apply (incident_oldPair G j v.val f).mp
    simpa only [hef] using hi
  have hleft : e.val.1.val = v.val.val := by
    rcases hi with hi | hi
    · exact congrArg Fin.val hi
    · have hh := congrArg Fin.val hi
      have hv := v.val.isLt
      dsimp [BinaryMatching.completeGraph,oldVertex] at hh
      omega
  let d : Fin j := ⟨e.val.2.val-G.n, by
    have he2 := e.val.2.isLt
    simp only [expand_n] at he2
    omega⟩
  have hed : crossPair G j v.val d = e := by
    apply Subtype.ext
    apply Prod.ext <;> apply Fin.ext
    · exact hleft.symm
    · dsimp [crossPair,d]
      omega
  exact ⟨d,crossPartner_eq G j N v.val d (by simpa only [hed] using he)⟩

def dummyEquiv (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    Fin j ≃ ↥(loopVertices (restrictMatching G j N)) :=
  Equiv.ofBijective (fun d => ⟨crossPartner G j N d,crossPartner_uncovered G j N d⟩)
    ⟨fun d c h => crossPartner_injective G j N (congrArg Subtype.val h), by
      intro v
      obtain ⟨d,hd⟩ := crossPartner_surjective G j N v
      exact ⟨d,Subtype.ext hd⟩⟩

@[simp] lemma incident_cross_old (G : Input) (j : ℕ) (v w : Fin G.n) (d : Fin j) :
    (BinaryMatching.completeGraph (expand G j).n).Incident
      (oldVertex G j v) (crossPair G j w d) ↔ w = v := by
  have hv := v.isLt
  simp only [MatchingEntropy.LooplessGraph.Incident, BinaryMatching.completeGraph,
    crossPair, oldVertex, Fin.ext_iff]
  omega

@[simp] lemma incident_cross_dummy (G : Input) (j : ℕ) (v : Fin G.n) (d c : Fin j) :
    (BinaryMatching.completeGraph (expand G j).n).Incident
      (dummyVertex G j d) (crossPair G j v c) ↔ c = d := by
  have hv := v.isLt
  simp only [MatchingEntropy.LooplessGraph.Incident, BinaryMatching.completeGraph,
    crossPair, dummyVertex, Fin.ext_iff]
  omega

@[simp] lemma not_incident_old_dummy (G : Input) (j : ℕ)
    (e : BinaryMatching.Pair G.n) (d : Fin j) :
    ¬ (BinaryMatching.completeGraph (expand G j).n).Incident
      (dummyVertex G j d) (oldPair G j e) := by
  have h1 := e.val.1.isLt
  have h2 := e.val.2.isLt
  simp only [MatchingEntropy.LooplessGraph.Incident, BinaryMatching.completeGraph,
    oldPair, dummyVertex, Fin.ext_iff]
  omega

def assembledEdges (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) : Finset (BinaryMatching.Pair (expand G j).n) := by
  classical
  exact M.val.image (oldPair G j) ∪ Finset.univ.image (fun d => crossPair G j (b d).val d)

lemma mem_assembledEdges (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) (e : BinaryMatching.Pair (expand G j).n) :
    e ∈ assembledEdges G j M b ↔
      (∃ f ∈ M.val, oldPair G j f = e) ∨ (∃ d, crossPair G j (b d).val d = e) := by
  classical
  simp only [assembledEdges, Finset.mem_union, Finset.mem_image, Finset.mem_univ, true_and]

lemma assembledEdges_perfect (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) :
    (BinaryMatching.completeGraph (expand G j).n).IsPerfectMatching
      (assembledEdges G j M b) := by
  classical
  intro x
  by_cases hx : x.val < G.n
  · let v : Fin G.n := ⟨x.val,hx⟩
    have hxv : x = oldVertex G j v := by apply Fin.ext; rfl
    rw [hxv]
    by_cases hv : ∃ e ∈ M.val, (BinaryMatching.completeGraph G.n).Incident v e
    · obtain ⟨e,he,hi⟩ := hv
      refine ⟨oldPair G j e, ⟨?_,(incident_oldPair G j v e).mpr hi⟩, ?_⟩
      · exact (mem_assembledEdges G j M b _).mpr (Or.inl ⟨e,he,rfl⟩)
      · intro f hf
        rcases (mem_assembledEdges G j M b f).mp hf.1 with ⟨a,ha,rfl⟩ | ⟨d,rfl⟩
        · exact congrArg (oldPair G j)
            (M.property v a ha e he ((incident_oldPair G j v a).mp hf.2) hi)
        · have hbv := (incident_cross_old G j v (b d).val d).mp hf.2
          have hloop := (Finset.mem_filter.mp (b d).property).2
          exact False.elim (hloop e he (by simpa only [hbv] using hi))
    · have hvloop : v ∈ loopVertices M := by
        simp only [loopVertices,Finset.mem_filter,Finset.mem_univ,true_and]
        simpa only [not_exists,not_and] using hv
      let d := b.symm ⟨v,hvloop⟩
      have hbd : (b d).val = v := congrArg Subtype.val (b.apply_symm_apply _)
      refine ⟨crossPair G j (b d).val d, ⟨?_, ?_⟩, ?_⟩
      · exact (mem_assembledEdges G j M b _).mpr (Or.inr ⟨d,rfl⟩)
      · exact (incident_cross_old G j v (b d).val d).mpr hbd
      · intro f hf
        rcases (mem_assembledEdges G j M b f).mp hf.1 with ⟨a,ha,rfl⟩ | ⟨c,rfl⟩
        · exact False.elim (hv ⟨a,ha,(incident_oldPair G j v a).mp hf.2⟩)
        · have hbc := (incident_cross_old G j v (b c).val c).mp hf.2
          have hcd : c = d := b.injective (Subtype.ext (hbc.trans hbd.symm))
          subst c
          rfl
  · let d : Fin j := ⟨x.val-G.n,by have := x.isLt; simp only [expand_n] at this; omega⟩
    have hxd : x = dummyVertex G j d := by apply Fin.ext; dsimp [dummyVertex,d]; omega
    rw [hxd]
    refine ⟨crossPair G j (b d).val d, ⟨?_,Or.inr rfl⟩, ?_⟩
    · exact (mem_assembledEdges G j M b _).mpr (Or.inr ⟨d,rfl⟩)
    · intro f hf
      rcases (mem_assembledEdges G j M b f).mp hf.1 with ⟨a,ha,rfl⟩ | ⟨c,rfl⟩
      · exact False.elim (not_incident_old_dummy G j a d hf.2)
      · have hcd := (incident_cross_dummy G j (b c).val d c).mp hf.2
        subst c
        rfl

def assembleMatching (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) : SupportedMatching G j := by
  refine ⟨⟨assembledEdges G j M b,assembledEdges_perfect G j M b⟩,?_⟩
  intro e he
  rcases (mem_assembledEdges G j M b e).mp he with ⟨a,ha,rfl⟩ | ⟨d,rfl⟩
  · exact a.val.1.isLt
  · exact (b d).val.isLt

lemma restrict_assemble (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) :
    restrictMatching G j (assembleMatching G j M b) = M := by
  classical
  apply Subtype.ext
  ext e
  rw [mem_restrictMatching]
  change oldPair G j e ∈ assembledEdges G j M b ↔ e ∈ M.val
  rw [mem_assembledEdges]
  constructor
  · rintro (⟨a,ha,hea⟩ | ⟨d,hd⟩)
    · exact (oldPair_injective G j hea) ▸ ha
    · exact False.elim (oldPair_ne_crossPair G j e (b d).val d hd.symm)
  · intro he
    exact Or.inl ⟨e,he,rfl⟩

lemma crossPartner_assemble (G : Input) (j : ℕ) (M : PartialMatching G.n)
    (b : Fin j ≃ ↥(loopVertices M)) (d : Fin j) :
    crossPartner G j (assembleMatching G j M b) d = (b d).val := by
  apply crossPartner_eq
  exact (mem_assembledEdges G j M b _).mpr (Or.inr ⟨d,rfl⟩)

lemma supported_edge_cases (G : Input) (j : ℕ) (N : SupportedMatching G j)
    (e : BinaryMatching.Pair (expand G j).n) (he : e ∈ N.val.val) :
    (∃ f ∈ (restrictMatching G j N).val, oldPair G j f = e) ∨
      (∃ d, crossPair G j (crossPartner G j N d) d = e) := by
  have hl := N.property e he
  by_cases hr : e.val.2.val < G.n
  · let f : BinaryMatching.Pair G.n :=
      ⟨(⟨e.val.1.val,hl⟩,⟨e.val.2.val,hr⟩),e.property⟩
    have hf : oldPair G j f = e := by
      apply Subtype.ext; apply Prod.ext <;> apply Fin.ext <;> rfl
    exact Or.inl ⟨f,(mem_restrictMatching G j N f).mpr (by simpa only [hf] using he),hf⟩
  · let d : Fin j := ⟨e.val.2.val-G.n,by
      have := e.val.2.isLt; simp only [expand_n] at this; omega⟩
    let v : Fin G.n := ⟨e.val.1.val,hl⟩
    have hf : crossPair G j v d = e := by
      apply Subtype.ext; apply Prod.ext <;> apply Fin.ext
      · rfl
      · dsimp [crossPair,d]; omega
    have hv := crossPartner_eq G j N v d (by simpa only [hf] using he)
    exact Or.inr ⟨d,by simpa only [hv] using hf⟩

lemma assemble_restrict (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    assembleMatching G j (restrictMatching G j N) (dummyEquiv G j N) = N := by
  classical
  apply Subtype.ext
  apply Subtype.ext
  ext e
  change e ∈ assembledEdges G j (restrictMatching G j N) (dummyEquiv G j N) ↔ e ∈ N.val.val
  rw [mem_assembledEdges]
  constructor
  · rintro (⟨f,hf,rfl⟩ | ⟨d,rfl⟩)
    · exact (mem_restrictMatching G j N f).mp hf
    · exact crossPartner_mem G j N d
  · exact supported_edge_cases G j N e

instance supportedMatchingFintype (G : Input) (j : ℕ) : Fintype (SupportedMatching G j) := by
  classical
  unfold SupportedMatching
  exact Fintype.ofFinite _

def assembleMatchingEquiv (G : Input) (j : ℕ) :
    ((M : PartialMatching G.n) × (Fin j ≃ ↥(loopVertices M))) ≃ SupportedMatching G j :=
  Equiv.ofBijective (fun z => assembleMatching G j z.1 z.2) ⟨by
    rintro ⟨M,b⟩ ⟨M',b'⟩ h
    have hm : M = M' := by
      have hh := congrArg (restrictMatching G j) h
      simpa only [restrict_assemble] using hh
    cases hm
    change assembleMatching G j M b = assembleMatching G j M b' at h
    have hb : b = b' := by
      apply Equiv.ext
      intro d
      apply Subtype.ext
      rw [← crossPartner_assemble G j M b d, h, crossPartner_assemble]
    cases hb
    rfl,
    fun N => ⟨⟨restrictMatching G j N,dummyEquiv G j N⟩,assemble_restrict G j N⟩⟩

def supportedMatchingEquiv (G : Input) (j : ℕ) :
    SupportedMatching G j ≃ ((M : PartialMatching G.n) × (Fin j ≃ ↥(loopVertices M))) :=
  (assembleMatchingEquiv G j).symm

lemma supportedMatchingEquiv_fst (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    (supportedMatchingEquiv G j N).1 = restrictMatching G j N := by
  have hh := congrArg (restrictMatching G j) ((assembleMatchingEquiv G j).apply_symm_apply N)
  change restrictMatching G j (assembleMatching G j
    (supportedMatchingEquiv G j N).1 (supportedMatchingEquiv G j N).2) = _ at hh
  simpa only [restrict_assemble] using hh

def supportedEdgeEquiv (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    (↥(restrictMatching G j N).val ⊕ Fin j) ≃ ↥N.val.val :=
  Equiv.ofBijective (fun x => match x with
    | Sum.inl e => ⟨oldPair G j e.val,(mem_restrictMatching G j N e.val).mp e.property⟩
    | Sum.inr d => ⟨crossPair G j (crossPartner G j N d) d,crossPartner_mem G j N d⟩)
    ⟨by
      intro x y h
      have hh := congrArg Subtype.val h
      cases x with
      | inl e =>
        cases y with
        | inl f => exact congrArg Sum.inl (Subtype.ext (oldPair_injective G j hh))
        | inr d => exact False.elim (oldPair_ne_crossPair G j e.val _ d hh)
      | inr d =>
        cases y with
        | inl e => exact False.elim (oldPair_ne_crossPair G j e.val _ d hh.symm)
        | inr c => exact congrArg Sum.inr (crossPair_injective G j hh).2,
      by
        intro e
        rcases supported_edge_cases G j N e.val e.property with ⟨f,hf,he⟩ | ⟨d,he⟩
        · exact ⟨Sum.inl ⟨f,hf⟩,Subtype.ext he⟩
        · exact ⟨Sum.inr d,Subtype.ext he⟩⟩

lemma supported_matching_weight (G : Input) (j : ℕ) (N : SupportedMatching G j) :
    (∏ e ∈ N.val.val, BinaryMatching.multiplicity (expand G j) e) =
      weight G (restrictMatching G j N) := by
  classical
  rw [← Finset.prod_coe_sort]
  have hprod := Fintype.prod_equiv (supportedEdgeEquiv G j N)
    (fun x => match x with
      | Sum.inl e => BinaryMatching.multiplicity G.ordinary e.val
      | Sum.inr d => loopMultiplicity G (crossPartner G j N d))
    (fun e : N.val.val => BinaryMatching.multiplicity (expand G j) e.val)
    (by
      intro x
      cases x with
      | inl e =>
        change BinaryMatching.multiplicity G.ordinary e.val =
          BinaryMatching.multiplicity (expand G j) (oldPair G j e.val)
        exact (multiplicity_expand_old G j e.val).symm
      | inr d =>
        change loopMultiplicity G (crossPartner G j N d) =
          BinaryMatching.multiplicity (expand G j) (crossPair G j (crossPartner G j N d) d)
        exact (multiplicity_expand_cross G j (crossPartner G j N d) d).symm)
  rw [← hprod,Fintype.prod_sum_type]
  have hloop := Fintype.prod_equiv (dummyEquiv G j N)
    (fun d => loopMultiplicity G (crossPartner G j N d))
    (fun v => loopMultiplicity G v.val) (fun _ => rfl)
  rw [hloop]
  simp only [Finset.prod_coe_sort,weight]

lemma unsupported_matching_weight_zero (G : Input) (j : ℕ)
    (N : (BinaryMatching.completeGraph (expand G j).n).Matching)
    (h : ¬ ∀ e ∈ N.val, e.val.1.val < G.n) :
    (∏ e ∈ N.val, BinaryMatching.multiplicity (expand G j) e) = 0 := by
  classical
  push Not at h
  obtain ⟨e,he,hl⟩ := h
  have hright := e.val.2.isLt
  have hleft := e.val.1.isLt
  have hlt := e.property
  simp only [expand_n] at hright hleft
  let f : BinaryMatching.Pair j :=
    ⟨(⟨e.val.1.val-G.n,by omega⟩,⟨e.val.2.val-G.n,by omega⟩),by
      change e.val.1.val-G.n < e.val.2.val-G.n
      change e.val.1.val < e.val.2.val at hlt
      omega⟩
  have hf : dummyPair G j f = e := by
    apply Subtype.ext
    apply Prod.ext <;> apply Fin.ext <;> dsimp [dummyPair,f] <;> omega
  apply Finset.prod_eq_zero he
  rw [← hf,multiplicity_expand_dummy]

end LoopMatching

end

end OAI