lean/OAI/Combinatorics/GraphThreshold/GraphEncoding.lean

import OAI.Combinatorics.GraphThreshold.Statement
import Mathlib.Algebra.Group.Action.Pointwise.Finset

namespace OAI

noncomputable section

open scoped Pointwise

namespace LeanBlast.SecondKahnKalai

/-- The non-loop edge set of an ordinary graph on `Fin n`. -/
def graphEdges {n : ℕ} (G : SimpleGraph (Fin n)) : Finset (Edge n) := by
  classical
  exact Finset.univ.filter (fun e => e.val ∈ G.edgeSet)

variable {n : ℕ}

/-- Vertex permutations act on unordered non-loop edges. -/
instance edgeMulAction : MulAction (Equiv.Perm (Fin n)) (Edge n) where
  smul σ e := ⟨Sym2.map σ e.val, fun h =>
    e.property ((Sym2.isDiag_map σ.injective).mp h)⟩
  one_smul e := by
    apply Subtype.ext
    change Sym2.map (1 : Equiv.Perm (Fin n)) e.val = e.val
    simp
  mul_smul σ τ e := by
    apply Subtype.ext
    change Sym2.map (σ * τ) e.val = Sym2.map σ (Sym2.map τ e.val)
    rw [Sym2.map_map]
    rfl

@[simp]
theorem edge_smul_val (σ : Equiv.Perm (Fin n)) (e : Edge n) :
    (σ • e).val = Sym2.map σ e.val := rfl

@[simp]
theorem mem_graphEdges (G : SimpleGraph (Fin n)) (e : Edge n) :
    e ∈ graphEdges G ↔ e.val ∈ G.edgeSet := by
  classical
  simp [graphEdges]

theorem edgeSet_graphOfEdges (W : Finset (Edge n)) :
    (graphOfEdges W).edgeSet = Subtype.val '' (W : Set (Edge n)) := by
  rw [graphOfEdges, SimpleGraph.edgeSet_fromEdgeSet]
  ext e
  constructor
  · exact And.left
  · rintro ⟨a, ha, rfl⟩
    exact ⟨⟨a, ha, rfl⟩, a.property⟩

@[simp]
theorem mem_edgeSet_graphOfEdges (W : Finset (Edge n)) (e : Edge n) :
    e.val ∈ (graphOfEdges W).edgeSet ↔ e ∈ W := by
  classical
  simp [graphOfEdges, e.property, Subtype.val_injective.eq_iff]

@[simp]
theorem graphEdges_graphOfEdges (W : Finset (Edge n)) :
    graphEdges (graphOfEdges W) = W := by
  classical
  ext e
  simp

@[simp]
theorem graphOfEdges_graphEdges (G : SimpleGraph (Fin n)) :
    graphOfEdges (graphEdges G) = G := by
  apply SimpleGraph.edgeSet_injective
  ext e
  by_cases he : e.IsDiag
  · simp [SimpleGraph.not_mem_edgeSet_of_isDiag, he]
  · exact (mem_edgeSet_graphOfEdges (graphEdges G) ⟨e, he⟩).trans
      (mem_graphEdges G ⟨e, he⟩)

/-- No graphs or edge sets are omitted or multiply represented. -/
def graphEdgeEquiv (n : ℕ) : Finset (Edge n) ≃ SimpleGraph (Fin n) where
  toFun := graphOfEdges
  invFun := graphEdges
  left_inv := graphEdges_graphOfEdges
  right_inv := graphOfEdges_graphEdges

theorem graphOfEdges_smul (σ : Equiv.Perm (Fin n)) (W : Finset (Edge n)) :
    graphOfEdges (σ • W) = (graphOfEdges W).map σ.toEmbedding := by
  apply SimpleGraph.edgeSet_injective
  rw [edgeSet_graphOfEdges, SimpleGraph.edgeSet_map, edgeSet_graphOfEdges,
    Finset.smul_finset_def, Finset.coe_image, Set.image_image, Set.image_image]
  rfl

theorem graphEdges_map (σ : Equiv.Perm (Fin n)) (G : SimpleGraph (Fin n)) :
    graphEdges (G.map σ.toEmbedding) = σ • graphEdges G := by
  apply (graphEdgeEquiv n).injective
  change graphOfEdges _ = graphOfEdges _
  rw [graphOfEdges_graphEdges, graphOfEdges_smul, graphOfEdges_graphEdges]

@[simp]
theorem graphOfEdges_empty : graphOfEdges (∅ : Finset (Edge n)) = ⊥ := by
  simp [graphOfEdges]

@[simp]
theorem graphEdges_bot : graphEdges (⊥ : SimpleGraph (Fin n)) = ∅ := by
  classical
  ext e
  simp

@[simp]
theorem graphEdges_top : graphEdges (⊤ : SimpleGraph (Fin n)) = Finset.univ := by
  classical
  ext e
  simp [e.property]

@[simp]
theorem graphOfEdges_univ : graphOfEdges (Finset.univ : Finset (Edge n)) = ⊤ := by
  rw [← graphEdges_top, graphOfEdges_graphEdges]

theorem graphEdges_mono {G H : SimpleGraph (Fin n)} (h : G ≤ H) :
    graphEdges G ⊆ graphEdges H := by
  intro e he
  exact (mem_graphEdges H e).mpr (SimpleGraph.edgeSet_mono h
    ((mem_graphEdges G e).mp he))

theorem graphOfEdges_mono {S T : Finset (Edge n)} (h : S ⊆ T) :
    graphOfEdges S ≤ graphOfEdges T := by
  apply SimpleGraph.fromEdgeSet_mono
  exact Set.image_mono h

@[simp]
theorem graphOfEdges_le_iff {S T : Finset (Edge n)} :
    graphOfEdges S ≤ graphOfEdges T ↔ S ⊆ T := by
  constructor
  · intro h
    simpa using graphEdges_mono h
  · exact graphOfEdges_mono

/-- Edge-set encoding preserves the ordinary unlabelled edge count. -/
def graphEdgesEquiv (G : SimpleGraph (Fin n)) : ↥(graphEdges G) ≃ G.edgeSet where
  toFun e := ⟨e.val.val, (mem_graphEdges G e.val).mp e.property⟩
  invFun e := ⟨⟨e.val, G.not_isDiag_of_mem_edgeSet e.property⟩,
    (mem_graphEdges G _).mpr e.property⟩
  left_inv _ := rfl
  right_inv _ := rfl

@[simp]
theorem card_graphEdges (G : SimpleGraph (Fin n)) :
    (graphEdges G).card = edgeCount G := by
  classical
  rw [edgeCount, Nat.card_eq_fintype_card, ← Fintype.card_coe]
  exact Fintype.card_congr (graphEdgesEquiv G)

@[simp]
theorem edgeCount_graphOfEdges (W : Finset (Edge n)) :
    edgeCount (graphOfEdges W) = W.card := by
  rw [← card_graphEdges, graphEdges_graphOfEdges]

theorem edgeCount_eq_card_edgeFinset {V : Type*} [Fintype V] (G : SimpleGraph V)
    [Fintype G.edgeSet] :
    edgeCount G = G.edgeFinset.card := by
  classical
  rw [edgeCount, Nat.card_eq_fintype_card, SimpleGraph.edgeFinset_card]

theorem edgeCount_eq_zero_iff {V : Type*} [Fintype V] (G : SimpleGraph V) :
    edgeCount G = 0 ↔ G = ⊥ := by
  classical
  rw [edgeCount_eq_card_edgeFinset, Finset.card_eq_zero]
  exact G.edgeFinset_eq_empty

theorem positive_copies_iff {V : Type*} (W : Finset (Edge n)) (H : SimpleGraph V) :
    0 < (graphOfEdges W).copyCount H ↔ H.IsContained (graphOfEdges W) :=
  SimpleGraph.copyCount_pos

end LeanBlast.SecondKahnKalai

end

end OAI