import Mathlib
import OAI.GroupTheory.ArithmeticGerms.Basic

namespace OAI

/-! Full arithmetic germ stabilizers and finite orbits. -/



namespace ArithmeticGerms

open scoped Pointwise

class ICC (G : Type*) [Group G] : Prop where
  infinite_conjugacyClass : ∀ g : G, g ≠ 1 → (ConjClasses.mk g).carrier.Infinite

section FiniteIndex
variable {K L : Type*} [Group K] [Group L]

lemma finiteIndex_comap (A : Subgroup L) [A.FiniteIndex] (f : K →* L) :
    (A.comap f).FiniteIndex := by
  refine ⟨?_⟩
  rw [Subgroup.index_comap]
  exact (Subgroup.isFiniteRelIndex_of_finiteIndex (H := A) (K := f.range)).relIndex_ne_zero

lemma finiteIndex_map (A : Subgroup K) [A.FiniteIndex] (f : K →* L)
    [f.range.FiniteIndex] : (A.map f).FiniteIndex := by
  refine ⟨?_⟩
  rw [Subgroup.index_map]
  exact mul_ne_zero (Subgroup.finiteIndex_of_le (H := A) le_sup_left).index_ne_zero
    Subgroup.FiniteIndex.index_ne_zero

lemma finiteIndex_image_of_relIndex (S T : Subgroup K) (hST : S ≤ T)
    [S.IsFiniteRelIndex T] (f : K →* L) [(T.map f).FiniteIndex] :
    (S.map f).FiniteIndex := by
  let φ := f.comp T.subtype
  have hr : φ.range = T.map f := by
    rw [← MonoidHom.map_range, Subgroup.range_subtype]
  have : φ.range.FiniteIndex := hr ▸ (inferInstance : (T.map f).FiniteIndex)
  have h := finiteIndex_map (S.subgroupOf T) φ
  have he : (S.subgroupOf T).map φ = S.map f := by
    rw [← Subgroup.map_map, Subgroup.map_subgroupOf_eq_of_le hST]
  exact he ▸ h

end FiniteIndex

section ICC
variable {G : Type*} [Group G] [ICC G]

theorem eq_one_of_centralizes_finiteIndex (A : Subgroup G) [A.FiniteIndex]
    (g : G) (hg : ∀ a ∈ A, g * a = a * g) : g = 1 := by
  by_contra hne
  have hle : A ≤ Subgroup.centralizer ({g} : Set G) := by
    intro a ha
    rw [Subgroup.mem_centralizer_iff]
    intro b hb
    rcases Set.mem_singleton_iff.mp hb with rfl
    exact hg a ha
  have : (Subgroup.centralizer ({g} : Set G)).FiniteIndex :=
    Subgroup.finiteIndex_of_le hle
  have hi : (MulAction.stabilizer (ConjAct G) g).FiniteIndex := by
    refine ⟨?_⟩
    have h := (Subgroup.FiniteIndex.index_ne_zero
      (H := Subgroup.centralizer ({g} : Set G)))
    have he : (Subgroup.centralizer ({g} : Set G)).index =
        (MulAction.stabilizer (ConjAct G) g).index := calc
      _ = ((MulAction.stabilizer (ConjAct G) g).comap
          (ConjAct.toConjAct (G := G)).toMonoidHom).index :=
        congrArg Subgroup.index (Subgroup.centralizer_eq_comap_stabilizer g)
      _ = _ := Subgroup.index_comap_of_surjective _
        (ConjAct.toConjAct (G := G)).surjective
    exact fun hz => h (he.trans hz)
  have : Finite (MulAction.orbit (ConjAct G) g) :=
    (MulAction.orbitEquivQuotientStabilizer (ConjAct G) g).finite_iff.mpr inferInstance
  have hf : (MulAction.orbit (ConjAct G) g).Finite := Set.toFinite _
  rw [ConjAct.orbit_eq_carrier_conjClasses] at hf
  exact (ICC.infinite_conjugacyClass g hne).not_finite hf

end ICC

namespace VirtualGraph
variable {G H : Type*} [Group G] [Group H]

noncomputable def toDomain (C : VirtualGraph G H) : C.graph ≃* C.domain :=
  MulEquiv.ofBijective ((MonoidHom.fst G H).subgroupMap C.graph)
    ⟨fun _ _ h => C.fst_injective (congrArg Subtype.val h),
      (MonoidHom.fst G H).subgroupMap_surjective C.graph⟩

noncomputable def toCodomain (C : VirtualGraph G H) : C.graph ≃* C.codomain :=
  MulEquiv.ofBijective ((MonoidHom.snd G H).subgroupMap C.graph)
    ⟨fun _ _ h => C.snd_injective (congrArg Subtype.val h),
      (MonoidHom.snd G H).subgroupMap_surjective C.graph⟩

noncomputable def iso (C : VirtualGraph G H) : C.domain ≃* C.codomain :=
  C.toDomain.symm.trans C.toCodomain

lemma pair_mem_graph (C : VirtualGraph G H) (a : C.domain) :
    ((a : G), (C.iso a : H)) ∈ C.graph := by
  have h := (C.toDomain.symm a).property
  have he := congrArg (fun x : C.domain => (x : G)) (C.toDomain.apply_symm_apply a)
  change ((C.toDomain.symm a).val.1, (C.toDomain.symm a).val.2) ∈ C.graph at h
  change ((a : G), (C.toDomain.symm a).val.2) ∈ C.graph
  change (C.toDomain.symm a).val.1 = (a : G) at he
  rwa [he] at h

lemma finiteRelIndex_of_fst (C : VirtualGraph G H) (S : Subgroup (G × H))
    (hS : S ≤ C.graph) [(S.map (MonoidHom.fst G H)).FiniteIndex] :
    S.IsFiniteRelIndex C.graph := by
  let φ := (MonoidHom.fst G H).comp C.graph.subtype
  have he : (S.map (MonoidHom.fst G H)).comap φ = S.subgroupOf C.graph := by
    ext x
    constructor
    · rintro ⟨y, hy, he⟩
      have hxy : (⟨y, hS hy⟩ : C.graph) = x := C.fst_injective he
      have hv : y = x.val := congrArg Subtype.val hxy
      change x.val ∈ S
      exact hv ▸ hy
    · intro hx
      exact ⟨x.val, hx, rfl⟩
  have hi := finiteIndex_comap (S.map (MonoidHom.fst G H)) φ
  rw [he] at hi
  exact Subgroup.isFiniteRelIndex_iff_finiteIndex.mpr hi

lemma commensurable_of_le (C D : VirtualGraph G H) (hle : C.graph ≤ D.graph) :
    C.graph.Commensurable D.graph := by
  exact ⟨D.finiteRelIndex_of_fst C.graph hle,
    ⟨(Subgroup.relIndex_eq_one.mpr hle).trans_ne one_ne_zero⟩⟩

def restriction (C : VirtualGraph G H) (S : Subgroup (G × H)) (hS : S ≤ C.graph)
    [S.IsFiniteRelIndex C.graph] : VirtualGraph G H where
  graph := S
  fst_injective := by
    intro x y h
    exact Subtype.ext (congrArg (fun t : C.graph => t.val)
      (C.fst_injective (a₁ := ⟨x.val, hS x.property⟩)
        (a₂ := ⟨y.val, hS y.property⟩) h))
  snd_injective := by
    intro x y h
    exact Subtype.ext (congrArg (fun t : C.graph => t.val)
      (C.snd_injective (a₁ := ⟨x.val, hS x.property⟩)
        (a₂ := ⟨y.val, hS y.property⟩) h))
  fst_finite := finiteIndex_image_of_relIndex S C.graph hS (MonoidHom.fst G H)
  snd_finite := finiteIndex_image_of_relIndex S C.graph hS (MonoidHom.snd G H)

theorem commensurable_iff_common_restriction (C D : VirtualGraph G H) :
    C.graph.Commensurable D.graph ↔
      ∃ R : VirtualGraph G H, R.graph ≤ C.graph ∧ R.graph ≤ D.graph := by
  constructor
  · intro h
    have : (C.graph ⊓ D.graph).IsFiniteRelIndex C.graph :=
      ⟨by rw [Subgroup.inf_relIndex_left]; exact h.2.relIndex_ne_zero⟩
    exact ⟨C.restriction (C.graph ⊓ D.graph) inf_le_left, inf_le_left, inf_le_right⟩
  · rintro ⟨R, hRC, hRD⟩
    exact (R.commensurable_of_le C hRC).symm.trans (R.commensurable_of_le D hRD)

lemma iso_extends (C D : VirtualGraph G H) (hle : C.graph ≤ D.graph) (a : C.domain) :
    (C.iso a : H) = D.iso ⟨a.val, (Subgroup.map_mono hle) a.property⟩ := by
  have he := D.fst_injective
    (a₁ := ⟨(a.val, (C.iso a : H)), hle (C.pair_mem_graph a)⟩)
    (a₂ := ⟨(a.val, (D.iso ⟨a.val, (Subgroup.map_mono hle) a.property⟩ : H)),
      D.pair_mem_graph ⟨a.val, (Subgroup.map_mono hle) a.property⟩⟩) rfl
  exact congrArg (fun x : D.graph => x.val.2) he

def ofEquiv (e : G ≃* H) : VirtualGraph G H where
  graph := e.toMonoidHom.graph
  fst_injective := by
    intro x y h
    apply Subtype.ext
    exact Prod.ext h (x.property.symm.trans ((congrArg e h).trans y.property))
  snd_injective := by
    intro x y h
    apply Subtype.ext
    exact Prod.ext (e.injective (x.property.trans (h.trans y.property.symm))) h
  fst_finite := by
    have he : e.toMonoidHom.graph.map (MonoidHom.fst G H) = ⊤ := by
      ext g
      exact ⟨fun _ => Subgroup.mem_top _, fun _ => ⟨(g, e g), rfl, rfl⟩⟩
    rw [he]
    infer_instance
  snd_finite := by
    have he : e.toMonoidHom.graph.map (MonoidHom.snd G H) = ⊤ := by
      ext h
      refine ⟨fun _ => Subgroup.mem_top _, fun _ => ?_⟩
      exact ⟨(e.symm h, h), e.apply_symm_apply h, rfl⟩
    rw [he]
    infer_instance

def conjugate (C : VirtualGraph G H) (k : G × H) : VirtualGraph G H where
  graph := C.graph.map (MulAut.conj k).toMonoidHom
  fst_injective := by
    rintro ⟨_, a, ha, rfl⟩ ⟨_, b, hb, rfl⟩ he
    have hab : (⟨a, ha⟩ : C.graph) = ⟨b, hb⟩ :=
      C.fst_injective ((MulAut.conj k.1).injective he)
    exact Subtype.ext (congrArg (MulAut.conj k) (congrArg Subtype.val hab))
  snd_injective := by
    rintro ⟨_, a, ha, rfl⟩ ⟨_, b, hb, rfl⟩ he
    have hab : (⟨a, ha⟩ : C.graph) = ⟨b, hb⟩ :=
      C.snd_injective ((MulAut.conj k.2).injective he)
    exact Subtype.ext (congrArg (MulAut.conj k) (congrArg Subtype.val hab))
  fst_finite := by
    have he : (C.graph.map (MulAut.conj k).toMonoidHom).map (MonoidHom.fst G H) =
        C.domain.map (MulAut.conj k.1).toMonoidHom := by
      simp only [domain, Subgroup.map_map]
      rfl
    refine ⟨?_⟩
    rw [he, MulEquiv.toMonoidHom_eq_coe, Subgroup.index_map_equiv]
    exact Subgroup.FiniteIndex.index_ne_zero
  snd_finite := by
    have he : (C.graph.map (MulAut.conj k).toMonoidHom).map (MonoidHom.snd G H) =
        C.codomain.map (MulAut.conj k.2).toMonoidHom := by
      simp only [codomain, Subgroup.map_map]
      rfl
    refine ⟨?_⟩
    rw [he, MulEquiv.toMonoidHom_eq_coe, Subgroup.index_map_equiv]
    exact Subgroup.FiniteIndex.index_ne_zero

lemma conjugate_graph (C : VirtualGraph G H) (k : G × H) :
    (C.conjugate k).graph = ConjAct.toConjAct k • C.graph := rfl

instance : MulAction (G × H) (VirtualGraph G H) where
  smul k C := C.conjugate k
  one_smul C := by
    apply VirtualGraph.ext
    change (C.conjugate 1).graph = C.graph
    rw [conjugate_graph, map_one, one_smul]
  mul_smul k l C := by
    apply VirtualGraph.ext
    change (C.conjugate (k * l)).graph = ((C.conjugate l).conjugate k).graph
    simp only [conjugate_graph, map_mul, mul_smul]

lemma smul_graph (C : VirtualGraph G H) (k : G × H) :
    (k • C).graph = ConjAct.toConjAct k • C.graph := rfl

def fullSubgroup (C : VirtualGraph G H) : Subgroup (G × H) :=
  Subgroup.Commensurable.commensurator C.graph

lemma graph_le_fullSubgroup (C : VirtualGraph G H) : C.graph ≤ C.fullSubgroup := by
  intro k hk
  change (ConjAct.toConjAct k • C.graph).Commensurable C.graph
  rw [Subgroup.conjAct_pointwise_smul_eq_self (Subgroup.le_normalizer hk)]

lemma snd_eq_one_of_mem_fullSubgroup [ICC H] (C : VirtualGraph G H)
    (k : G × H) (hk : k ∈ C.fullSubgroup) (hfst : k.1 = 1) : k.2 = 1 := by
  let S := C.graph ⊓ ConjAct.toConjAct k • C.graph
  have hcomm : (ConjAct.toConjAct k • C.graph).Commensurable C.graph := hk
  have : S.IsFiniteRelIndex C.graph :=
    ⟨by change (C.graph ⊓ _).relIndex C.graph ≠ 0
        rw [Subgroup.inf_relIndex_left]; exact hcomm.1.relIndex_ne_zero⟩
  have : (S.map (MonoidHom.snd G H)).FiniteIndex :=
    finiteIndex_image_of_relIndex S C.graph inf_le_left _
  apply eq_one_of_centralizes_finiteIndex (S.map (MonoidHom.snd G H)) k.2
  rintro a ⟨x, hx, rfl⟩
  have hy : k⁻¹ * x * k ∈ C.graph := by
    have h := Subgroup.mem_pointwise_smul_iff_inv_smul_mem.mp hx.2
    simpa only [← map_inv, ConjAct.toConjAct_inv_smul] using h
  have he : (⟨k⁻¹ * x * k, hy⟩ : C.graph) = ⟨x, hx.1⟩ := by
    apply C.fst_injective
    change k.1⁻¹ * x.1 * k.1 = x.1
    simp [hfst]
  have he' := congrArg (fun y : C.graph => y.val.2) he
  change k.2⁻¹ * x.2 * k.2 = x.2 at he'
  calc
    k.2 * x.2 = k.2 * (k.2⁻¹ * x.2 * k.2) := congrArg (k.2 * ·) he'.symm
    _ = x.2 * k.2 := by group

lemma fst_eq_one_of_mem_fullSubgroup [ICC G] (C : VirtualGraph G H)
    (k : G × H) (hk : k ∈ C.fullSubgroup) (hsnd : k.2 = 1) : k.1 = 1 := by
  let S := C.graph ⊓ ConjAct.toConjAct k • C.graph
  have hcomm : (ConjAct.toConjAct k • C.graph).Commensurable C.graph := hk
  have : S.IsFiniteRelIndex C.graph :=
    ⟨by change (C.graph ⊓ _).relIndex C.graph ≠ 0
        rw [Subgroup.inf_relIndex_left]; exact hcomm.1.relIndex_ne_zero⟩
  have : (S.map (MonoidHom.fst G H)).FiniteIndex :=
    finiteIndex_image_of_relIndex S C.graph inf_le_left _
  apply eq_one_of_centralizes_finiteIndex (S.map (MonoidHom.fst G H)) k.1
  rintro a ⟨x, hx, rfl⟩
  have hy : k⁻¹ * x * k ∈ C.graph := by
    have h := Subgroup.mem_pointwise_smul_iff_inv_smul_mem.mp hx.2
    simpa only [← map_inv, ConjAct.toConjAct_inv_smul] using h
  have he : (⟨k⁻¹ * x * k, hy⟩ : C.graph) = ⟨x, hx.1⟩ := by
    apply C.snd_injective
    change k.2⁻¹ * x.2 * k.2 = x.2
    simp [hsnd]
  have he' := congrArg (fun y : C.graph => y.val.1) he
  change k.1⁻¹ * x.1 * k.1 = x.1 at he'
  calc
    k.1 * x.1 = k.1 * (k.1⁻¹ * x.1 * k.1) := congrArg (k.1 * ·) he'.symm
    _ = x.1 * k.1 := by group

def full [ICC G] [ICC H] (C : VirtualGraph G H) : VirtualGraph G H where
  graph := C.fullSubgroup
  fst_injective := by
    apply (injective_iff_map_eq_one _).mpr
    intro k hk
    apply Subtype.ext
    exact Prod.ext hk (C.snd_eq_one_of_mem_fullSubgroup k.val k.property hk)
  snd_injective := by
    apply (injective_iff_map_eq_one _).mpr
    intro k hk
    apply Subtype.ext
    exact Prod.ext (C.fst_eq_one_of_mem_fullSubgroup k.val k.property hk) hk
  fst_finite := Subgroup.finiteIndex_of_le (Subgroup.map_mono C.graph_le_fullSubgroup)
  snd_finite := Subgroup.finiteIndex_of_le (Subgroup.map_mono C.graph_le_fullSubgroup)

lemma commensurable_full [ICC G] [ICC H] (C : VirtualGraph G H) :
    C.graph.Commensurable C.full.graph :=
  C.commensurable_of_le C.full C.graph_le_fullSubgroup

lemma finiteIndex_in_full [ICC G] [ICC H] (C : VirtualGraph G H) :
    C.graph.IsFiniteRelIndex C.full.graph :=
  C.commensurable_full.1

end VirtualGraph

def germSetoid (G H : Type*) [Group G] [Group H] : Setoid (VirtualGraph G H) where
  r C D := C.graph.Commensurable D.graph
  iseqv := ⟨fun C => .refl C.graph, fun h => h.symm, fun h h' => h.trans h'⟩

def Germ (G H : Type*) [Group G] [Group H] := Quotient (germSetoid G H)

namespace Germ
variable {G H : Type*} [Group G] [Group H]

def mk (C : VirtualGraph G H) : Germ G H := Quotient.mk (germSetoid G H) C

@[elab_as_elim]
lemma induction_on {P : Germ G H → Prop} (d : Germ G H)
    (h : ∀ C, P (mk C)) : P d := Quotient.inductionOn d h

lemma mk_eq_mk_iff (C D : VirtualGraph G H) :
    mk C = mk D ↔ C.graph.Commensurable D.graph := Quotient.eq

instance : MulAction (G × H) (Germ G H) where
  smul k d := Quotient.map (k • ·)
    (fun C D (h : C.graph.Commensurable D.graph) =>
      Subgroup.Commensurable.smul (ConjAct.toConjAct k) h) d
  one_smul d := by
    induction d using induction_on with | h C =>
      exact congrArg mk (one_smul (G × H) C)
  mul_smul k l d := by
    induction d using induction_on with | h C =>
      exact congrArg mk (mul_smul k l C)

@[simp]
lemma smul_mk (k : G × H) (C : VirtualGraph G H) : k • mk C = mk (k • C) := rfl

section ICC
variable [ICC G] [ICC H]

def full (d : Germ G H) : VirtualGraph G H :=
  Quotient.lift VirtualGraph.full
    (fun _ _ h => VirtualGraph.ext (Subgroup.Commensurable.eq h)) d

@[simp]
lemma full_mk (C : VirtualGraph G H) : (mk C).full = C.full := rfl

theorem full_graph_eq_stabilizer (d : Germ G H) :
    d.full.graph = MulAction.stabilizer (G × H) d := by
  induction d using induction_on with | h C =>
    ext k
    change (ConjAct.toConjAct k • C.graph).Commensurable C.graph ↔ k • mk C = mk C
    exact (mk_eq_mk_iff (k • C) C).symm

lemma mk_full (d : Germ G H) : mk d.full = d := by
  induction d using induction_on with | h C =>
    exact (mk_eq_mk_iff _ _).mpr C.commensurable_full.symm

lemma mem_full_iff (d : Germ G H) (k : G × H) :
    k ∈ d.full.graph ↔ k • d = d := by
  rw [full_graph_eq_stabilizer, MulAction.mem_stabilizer_iff]

theorem representative_in_full (C : VirtualGraph G H) :
    C.graph ≤ (mk C).full.graph ∧ C.graph.IsFiniteRelIndex (mk C).full.graph :=
  ⟨C.graph_le_fullSubgroup, C.finiteIndex_in_full⟩

theorem eq_mk_of_fixed_by_finiteIndex (C : VirtualGraph G H)
    (S : Subgroup (G × H)) (hS : S ≤ C.graph) [S.IsFiniteRelIndex C.graph]
    (d : Germ G H) (hfix : ∀ k ∈ S, k • d = d) : d = mk C := by
  let R := C.restriction S hS
  have hRC : R.graph ≤ C.graph := hS
  have hRD : R.graph ≤ d.full.graph := fun k hk => (mem_full_iff d k).mpr (hfix k hk)
  calc
    d = mk d.full := (mk_full d).symm
    _ = mk C := (mk_eq_mk_iff _ _).mpr
      ((R.commensurable_of_le d.full hRD).symm.trans (R.commensurable_of_le C hRC))

theorem eq_of_fixed_by_finiteIndex (d x : Germ G H) (S : Subgroup (G × H))
    (hS : S ≤ MulAction.stabilizer (G × H) d)
    [S.IsFiniteRelIndex (MulAction.stabilizer (G × H) d)]
    (hfix : ∀ k ∈ S, k • x = x) : x = d := by
  have h' : S ≤ d.full.graph := by rwa [full_graph_eq_stabilizer]
  have : S.IsFiniteRelIndex d.full.graph := by
    rw [full_graph_eq_stabilizer]
    infer_instance
  exact (eq_mk_of_fixed_by_finiteIndex d.full S h' x hfix).trans (mk_full d)

theorem finite_orbit_iff_eq_mk (C : VirtualGraph G H) (d : Germ G H) :
    (MulAction.orbit C.graph d).Finite ↔ d = mk C := by
  constructor
  · intro hf
    have : Finite (MulAction.orbit C.graph d) := Set.finite_coe_iff.mpr hf
    have : Finite (C.graph ⧸ MulAction.stabilizer C.graph d) :=
      (MulAction.orbitEquivQuotientStabilizer C.graph d).finite_iff.mp inferInstance
    let A := MulAction.stabilizer C.graph d
    have : A.FiniteIndex := Subgroup.finiteIndex_of_finite_quotient
    let S := A.map C.graph.subtype
    have he : S.subgroupOf C.graph = A := by
      change (A.map C.graph.subtype).comap C.graph.subtype = A
      exact Subgroup.comap_map_eq_self (by simp)
    have : S.IsFiniteRelIndex C.graph := by
      apply Subgroup.isFiniteRelIndex_iff_finiteIndex.mpr
      rw [he]
      infer_instance
    apply eq_mk_of_fixed_by_finiteIndex C S (Subgroup.map_subtype_le A) d
    rintro k ⟨a, ha, rfl⟩
    exact ha
  · rintro rfl
    apply (Set.finite_singleton (mk C)).subset
    rintro d ⟨k, rfl⟩
    exact (mem_full_iff (mk C) k.val).mp (C.graph_le_fullSubgroup k.property)

theorem finite_orbit_iff (d x : Germ G H) :
    (MulAction.orbit (MulAction.stabilizer (G × H) d) x).Finite ↔ x = d := by
  rw [← full_graph_eq_stabilizer]
  simpa only [mk_full] using finite_orbit_iff_eq_mk d.full x

end ICC

def inner (g : G) : Germ G G := mk (VirtualGraph.ofEquiv (MulAut.conj g))

theorem inner_injective [ICC G] : Function.Injective (inner : G → Germ G G) := by
  intro g h hgh
  obtain ⟨R, hg, hh⟩ := (VirtualGraph.commensurable_iff_common_restriction _ _).mp
    ((mk_eq_mk_iff _ _).mp hgh)
  have he : h⁻¹ * g = 1 := by
    apply eq_one_of_centralizes_finiteIndex R.domain (h⁻¹ * g)
    intro a ha
    have hc := (MonoidHom.mem_graph.mp (hg (R.pair_mem_graph ⟨a, ha⟩))).trans
      (MonoidHom.mem_graph.mp (hh (R.pair_mem_graph ⟨a, ha⟩))).symm
    change g * a * g⁻¹ = h * a * h⁻¹ at hc
    apply mul_inv_eq_iff_eq_mul.mp
    calc
      (h⁻¹ * g) * a * (h⁻¹ * g)⁻¹ = h⁻¹ * (g * a * g⁻¹) * h := by group
      _ = h⁻¹ * (h * a * h⁻¹) * h := by rw [hc]
      _ = a := by group
  exact (inv_mul_eq_one.mp he).symm

end Germ

theorem full_stabilizers_and_finite_orbit_test
    {G H : Type*} [Group G] [Group H] [ICC G] [ICC H] (C : VirtualGraph G H) :
    Function.Injective (Germ.inner : G → Germ G G) ∧
    Function.Injective (Germ.inner : H → Germ H H) ∧
    ∃ (F : VirtualGraph G H) (hle : C.graph ≤ F.graph),
      F.graph = MulAction.stabilizer (G × H) (Germ.mk C) ∧
      C.graph.IsFiniteRelIndex F.graph ∧
      (∀ a : C.domain,
        (C.iso a : H) = F.iso ⟨a.val, (Subgroup.map_mono hle) a.property⟩) ∧
      (∀ x : Germ G H, (MulAction.orbit F.graph x).Finite ↔ x = Germ.mk C) ∧
      (∀ x : Germ G H, (MulAction.orbit C.graph x).Finite ↔ x = Germ.mk C) := by
  refine ⟨Germ.inner_injective, Germ.inner_injective, C.full, C.graph_le_fullSubgroup,
    Germ.full_graph_eq_stabilizer (Germ.mk C), C.finiteIndex_in_full,
    C.iso_extends C.full C.graph_le_fullSubgroup, ?_, Germ.finite_orbit_iff_eq_mk C⟩
  intro x
  have hfull : Germ.mk C.full = Germ.mk C := Germ.mk_full (Germ.mk C)
  simpa only [hfull] using Germ.finite_orbit_iff_eq_mk C.full x

end ArithmeticGerms

end OAI