import Mathlib
import OAI.GroupTheory.ArithmeticGerms.Basic

namespace OAI

/-! Projective Hilbert bundles and exact induction. -/

namespace GermBundles
attribute [local instance] Classical.propDecidable
open scoped BigOperators InnerProductSpace

structure ScalarCocycle (K : Type*) [Group K] where
  val : K → K → Circle
  mul_assoc : ∀ g h j, val g h * val (g * h) j = val h j * val g (h * j)
  one_left : ∀ g, val 1 g = 1
  one_right : ∀ g, val g 1 = 1

section Bundles

variable {K X : Type*} [Group K] [MulAction K X]
variable (α : ScalarCocycle K) (E : X → Type*)
variable [∀ x, NormedAddCommGroup (E x)] [∀ x, InnerProductSpace ℂ (E x)]

attribute [local instance] Classical.propDecidable

structure ProjectiveBundle where
  action : K → lp E 2 ≃ₗᵢ[ℂ] lp E 2
  fibre : ∀ (k : K) (x y : X), k • x = y → E x ≃ₗᵢ[ℂ] E y
  action_single : ∀ (k : K) (x y : X) (h : k • x = y) (v : E x),
    action k (lp.single 2 x v) = lp.single 2 y (fibre k x y h v)
  action_one : ∀ v, action 1 v = v
  action_mul : ∀ g h v, action g (action h v) =
    (α.val g h : ℂ) • action (g * h) v

variable {α E}

variable {F : X → Type*}
variable [∀ x, NormedAddCommGroup (F x)] [∀ x, InnerProductSpace ℂ (F x)]

def Intertwines (B : ProjectiveBundle α E) (C : ProjectiveBundle α F)
    (T : lp E 2 →L[ℂ] lp F 2) : Prop :=
  ∀ k v, T (B.action k v) = C.action k (T v)

end Bundles

section BuildBundle

variable {X : Type*} {E F : X → Type*}
variable [∀ x, NormedAddCommGroup (E x)] [∀ x, InnerProductSpace ℂ (E x)]
variable [∀ x, NormedAddCommGroup (F x)] [∀ x, InnerProductSpace ℂ (F x)]

private theorem relabel_pi_apply (e : X ≃ X)
    (u : ∀ x y, e x = y → E x ≃ₗᵢ[ℂ] F y) (f : ∀ x, E x) (x : X) :
    u (e.symm (e x)) (e x) (e.apply_symm_apply (e x)) (f (e.symm (e x))) =
      u x (e x) rfl (f x) := by
  have haux (z : X) (hz : z = x) (he : e z = e x) :
      u z (e x) he (f z) = u x (e x) rfl (f x) := by
    subst z
    rfl
  exact haux (e.symm (e x)) (e.symm_apply_apply x) (e.apply_symm_apply (e x))

private theorem relabel_pi_right (e : X ≃ X)
    (u : ∀ x y, e x = y → E x ≃ₗᵢ[ℂ] F y) (f : ∀ x, F x) (y : X) :
    u (e.symm y) y (e.apply_symm_apply y)
      ((u (e.symm y) (e (e.symm y)) rfl).symm (f (e (e.symm y)))) = f y := by
  have haux (x y : X) (he : e x = y) :
      u x y he ((u x (e x) rfl).symm (f (e x))) = f y := by
    subst y
    exact (u x (e x) rfl).apply_symm_apply _
  exact haux (e.symm y) y (e.apply_symm_apply y)

noncomputable def relabel (e : X ≃ X)
    (u : ∀ x y, e x = y → E x ≃ₗᵢ[ℂ] F y) : lp E 2 ≃ₗᵢ[ℂ] lp F 2 where
  toLinearEquiv :=
    { toFun := fun v => ⟨fun y => u (e.symm y) y (e.apply_symm_apply y) (v (e.symm y)), by
        apply memℓp_gen
        convert! ((lp.memℓp v).summable (by norm_num)).comp_injective e.symm.injective using 1
        all_goals first | rfl | (simp only [LinearIsometryEquiv.norm_map]; rfl)⟩
      invFun := fun v => ⟨fun x => (u x (e x) rfl).symm (v (e x)), by
        apply memℓp_gen
        convert! ((lp.memℓp v).summable (by norm_num)).comp_injective e.injective using 1
        all_goals first | rfl | (simp only [LinearIsometryEquiv.norm_map]; rfl)⟩
      left_inv := by
        intro v
        apply lp.ext
        funext x
        change (u x (e x) rfl).symm
          (u (e.symm (e x)) (e x) (e.apply_symm_apply (e x)) (v.val (e.symm (e x)))) = v.val x
        exact (congrArg (u x (e x) rfl).symm (relabel_pi_apply e u (fun i => v i) x)).trans
          ((u x (e x) rfl).symm_apply_apply (v x))
      right_inv := by
        intro v
        apply lp.ext
        funext y
        exact relabel_pi_right e u (fun i => v i) y
      map_add' := by
        intro v w
        apply lp.ext
        funext y
        change u _ _ _ (v _ + w _) = u _ _ _ (v _) + u _ _ _ (w _)
        exact map_add _ _ _
      map_smul' := by
        intro a v
        apply lp.ext
        funext y
        change u _ _ _ (a • v _) = a • u _ _ _ (v _)
        exact map_smul _ _ _ }
  norm_map' := by
    intro v
    rw [lp.norm_eq_tsum_rpow (by norm_num), lp.norm_eq_tsum_rpow (by norm_num)]
    congr 1
    change (∑' y, ‖u (e.symm y) y (e.apply_symm_apply y) (v (e.symm y))‖ ^ (2 : ENNReal).toReal) = _
    simp only [LinearIsometryEquiv.norm_map]
    convert! e.symm.tsum_eq (fun x => ‖v x‖ ^ (2 : ENNReal).toReal) using 1

theorem relabel_apply (e : X ≃ X) (u : ∀ x y, e x = y → E x ≃ₗᵢ[ℂ] F y)
    (v : lp E 2) (x y : X) (h : e x = y) : relabel e u v y = u x y h (v x) := by
  subst y
  change u (e.symm (e x)) (e x) (e.apply_symm_apply (e x)) (v.val (e.symm (e x))) = u x (e x) rfl (v.val x)
  exact relabel_pi_apply e u (fun i => v i) x

theorem relabel_single (e : X ≃ X) (u : ∀ x y, e x = y → E x ≃ₗᵢ[ℂ] F y)
    (x y : X) (h : e x = y) (v : E x) :
    relabel e u (lp.single 2 x v) = lp.single 2 y (u x y h v) := by
  apply lp.ext
  funext z
  by_cases hz : z = y
  · subst z
    rw [relabel_apply e u _ x y h, lp.single_apply_self, lp.single_apply_self]
  · have hn : e.symm z ≠ x := by
      intro he
      apply hz
      rw [← h, ← he, e.apply_symm_apply]
    change u (e.symm z) z (e.apply_symm_apply z) ((lp.single 2 x v) (e.symm z)) = _
    rw [lp.single_apply_ne 2 x v hn, map_zero, lp.single_apply_ne 2 y _ hz]

end BuildBundle

section FibreSystem

variable {K X : Type*} [Group K] [MulAction K X]
variable (α : ScalarCocycle K) (E : X → Type*)
variable [∀ x, NormedAddCommGroup (E x)] [∀ x, InnerProductSpace ℂ (E x)]

structure FibreSystem where
  unitary : ∀ (k : K) (x y : X), k • x = y → E x ≃ₗᵢ[ℂ] E y
  one : ∀ x v, unitary 1 x x (one_smul K x) v = v
  mul : ∀ g h x y z (hy : h • x = y) (hz : g • y = z) (hgh : (g * h) • x = z) v,
    unitary g y z hz (unitary h x y hy v) = (α.val g h : ℂ) • unitary (g * h) x z hgh v

variable {α E}

noncomputable def FibreSystem.toBundle (U : FibreSystem α E) : ProjectiveBundle α E where
  action k := relabel (MulAction.toPerm k) (U.unitary k)
  fibre := U.unitary
  action_single k x y h v := relabel_single (MulAction.toPerm k) (U.unitary k) x y h v
  action_one := by
    intro v
    have he : (relabel (MulAction.toPerm (1 : K)) (U.unitary 1)).toContinuousLinearEquiv.toContinuousLinearMap =
        ContinuousLinearMap.id ℂ (lp E 2) := by
      apply lp.ext_continuousLinearMap (by norm_num)
      intro x
      apply ContinuousLinearMap.ext
      intro w
      change relabel (MulAction.toPerm (1 : K)) (U.unitary 1) (lp.single 2 x w) = lp.single 2 x w
      rw [relabel_single (MulAction.toPerm (1 : K)) (U.unitary 1) x x (one_smul K x), U.one]
    exact DFunLike.congr_fun he v
  action_mul := by
    intro g h v
    have he :
        (relabel (MulAction.toPerm g) (U.unitary g)).toContinuousLinearEquiv.toContinuousLinearMap.comp
          (relabel (MulAction.toPerm h) (U.unitary h)).toContinuousLinearEquiv.toContinuousLinearMap =
        (α.val g h : ℂ) • (relabel (MulAction.toPerm (g * h)) (U.unitary (g * h))).toContinuousLinearEquiv.toContinuousLinearMap := by
      apply lp.ext_continuousLinearMap (by norm_num)
      intro x
      apply ContinuousLinearMap.ext
      intro w
      change relabel (MulAction.toPerm g) (U.unitary g)
        (relabel (MulAction.toPerm h) (U.unitary h) (lp.single 2 x w)) =
        (α.val g h : ℂ) • relabel (MulAction.toPerm (g * h)) (U.unitary (g * h)) (lp.single 2 x w)
      rw [relabel_single (MulAction.toPerm h) (U.unitary h) x (h • x) rfl,
        relabel_single (MulAction.toPerm g) (U.unitary g) (h • x) ((g * h) • x) (mul_smul g h x).symm,
        relabel_single (MulAction.toPerm (g * h)) (U.unitary (g * h)) x ((g * h) • x) rfl]
      erw [U.mul g h x (h • x) ((g * h) • x) rfl (mul_smul g h x).symm rfl w,
        lp.single_smul]
    exact DFunLike.congr_fun he v

end FibreSystem

noncomputable section ExactInduction

attribute [local instance] Classical.propDecidable

variable {K : Type*} [Group K]

def ScalarCocycle.restrict (α : ScalarCocycle K) (C : Subgroup K) : ScalarCocycle C where
  val g h := α.val g h
  mul_assoc g h j := α.mul_assoc g h j
  one_left g := α.one_left g
  one_right g := α.one_right g

structure ProjectiveRepresentation (α : ScalarCocycle K) (V : Type*)
    [NormedAddCommGroup V] [InnerProductSpace ℂ V] where
  unitary : K → V ≃ₗᵢ[ℂ] V
  one : ∀ v, unitary 1 v = v
  mul : ∀ g h v, unitary g (unitary h v) = (α.val g h : ℂ) • unitary (g * h) v

variable (C : Subgroup K)

structure CosetSection where
  repr : K ⧸ C → K
  repr_spec : ∀ x, QuotientGroup.mk (repr x) = x
  repr_one : repr (QuotientGroup.mk 1) = 1

noncomputable def chooseCosetSection : CosetSection C where
  repr x := if x = QuotientGroup.mk 1 then 1 else x.out
  repr_spec x := by
    split_ifs with h
    · exact h.symm
    · exact QuotientGroup.out_eq' x
  repr_one := by simp

variable {C}

def CosetSection.correction (r : CosetSection C) (s : K) (x : K ⧸ C) : C :=
  ⟨(r.repr (s • x))⁻¹ * s * r.repr x, by
    rw [mul_assoc]
    apply QuotientGroup.eq.mp
    rw [r.repr_spec, ← smul_eq_mul, ← MulAction.Quotient.smul_mk, r.repr_spec]⟩

@[simp] theorem CosetSection.correction_val (r : CosetSection C) (s : K) (x : K ⧸ C) :
    (r.correction s x : K) = (r.repr (s • x))⁻¹ * s * r.repr x := rfl

@[simp] theorem CosetSection.repr_mul_correction (r : CosetSection C) (s : K) (x : K ⧸ C) :
    r.repr (s • x) * (r.correction s x : K) = s * r.repr x := by
  rw [correction_val]
  group

@[simp] theorem CosetSection.correction_one (r : CosetSection C) (x : K ⧸ C) :
    r.correction 1 x = 1 := by
  apply Subtype.ext
  simp [correction]

@[simp] theorem CosetSection.correction_mul (r : CosetSection C) (s t : K) (x : K ⧸ C) :
    r.correction s (t • x) * r.correction t x = r.correction (s * t) x := by
  apply Subtype.ext
  simp only [Subgroup.coe_mul, correction_val, mul_smul]
  group

def CosetSection.phase (r : CosetSection C) (α : ScalarCocycle K) (s : K) (x : K ⧸ C) : Circle :=
  α.val s (r.repr x) / α.val (r.repr (s • x)) (r.correction s x)

@[simp] theorem CosetSection.phase_one (r : CosetSection C) (α : ScalarCocycle K) (x : K ⧸ C) :
    r.phase α 1 x = 1 := by
  simp [phase, α.one_left, α.one_right]

theorem cocycle_transport_phase (α : ScalarCocycle K) (s t x y z a b : K)
    (ha : z * a = s * y) (hb : y * b = t * x) :
    (α.val s y / α.val z a) * (α.val t x / α.val y b) * α.val a b =
      α.val s t * (α.val (s * t) x / α.val z (a * b)) := by
  have hid : α.val s y * α.val t x * α.val a b * α.val z (a * b) =
      α.val s t * α.val (s * t) x * (α.val z a * α.val y b) := by
    calc
      _ = α.val t x * α.val s y * (α.val a b * α.val z (a * b)) := by ac_rfl
      _ = α.val t x * α.val s y * (α.val z a * α.val (z * a) b) := by
        rw [α.mul_assoc z a b]
      _ = α.val z a * α.val t x * (α.val s y * α.val (s * y) b) := by
        rw [ha]
        ac_rfl
      _ = α.val z a * α.val t x * (α.val y b * α.val s (y * b)) := by
        rw [α.mul_assoc s y b]
      _ = (α.val t x * α.val s (t * x)) * (α.val z a * α.val y b) := by
        rw [hb]
        ac_rfl
      _ = _ := by rw [← α.mul_assoc s t x]
  rw [div_mul_div_comm, div_mul_eq_mul_div, mul_div_assoc]
  simpa only [mul_div_assoc] using div_eq_div_iff_mul_eq_mul.mpr hid

theorem CosetSection.phase_mul (r : CosetSection C) (α : ScalarCocycle K) (s t : K)
    (x : K ⧸ C) :
    r.phase α s (t • x) * r.phase α t x * α.val (r.correction s (t • x)) (r.correction t x) =
      α.val s t * r.phase α (s * t) x := by
  unfold phase
  have h := cocycle_transport_phase α s t (r.repr x) (r.repr (t • x))
    (r.repr (s • t • x)) (r.correction s (t • x)) (r.correction t x)
    (r.repr_mul_correction s (t • x)) (r.repr_mul_correction t x)
  simpa only [← Subgroup.coe_mul, correction_mul, mul_smul] using h

variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]

def circleUnitary (z : Circle) : V ≃ₗᵢ[ℂ] V where
  toLinearEquiv :=
    { toFun := fun v => (z : ℂ) • v
      invFun := fun v => ((z⁻¹ : Circle) : ℂ) • v
      left_inv := by intro v; simp [smul_smul]
      right_inv := by intro v; simp [smul_smul]
      map_add' := by intro v w; exact smul_add _ _ _
      map_smul' := by intro a v; exact smul_comm _ _ _ }
  norm_map' := by intro v; simp [norm_smul, Circle.norm_coe]

@[simp] theorem circleUnitary_apply (z : Circle) (v : V) : circleUnitary z v = (z : ℂ) • v := rfl

def CosetSection.inducedUnitary (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (s : K) (x : K ⧸ C) : V ≃ₗᵢ[ℂ] V :=
  (γ.unitary (r.correction s x)).trans (circleUnitary (r.phase α s x))

@[simp] theorem CosetSection.inducedUnitary_apply (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (s : K) (x : K ⧸ C) (v : V) :
    r.inducedUnitary α γ s x v = (r.phase α s x : ℂ) • γ.unitary (r.correction s x) v := rfl

@[simp] theorem CosetSection.inducedUnitary_one (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (x : K ⧸ C) (v : V) :
    r.inducedUnitary α γ 1 x v = v := by
  simp [γ.one]

theorem CosetSection.inducedUnitary_mul (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (s t : K) (x : K ⧸ C) (v : V) :
    r.inducedUnitary α γ s (t • x) (r.inducedUnitary α γ t x v) =
      (α.val s t : ℂ) • r.inducedUnitary α γ (s * t) x v := by
  simp only [inducedUnitary_apply, map_smul, γ.mul, smul_smul]
  rw [correction_mul]
  congr 1
  have hp := congrArg (fun z : Circle => (z : ℂ)) (r.phase_mul α s t x)
  simpa only [Circle.coe_mul, ScalarCocycle.restrict, mul_assoc, mul_left_comm] using hp

def CosetSection.change (r r' : CosetSection C) (x : K ⧸ C) : C :=
  ⟨(r.repr x)⁻¹ * r'.repr x, QuotientGroup.eq.mp ((r.repr_spec x).trans (r'.repr_spec x).symm)⟩

@[simp] theorem CosetSection.repr_mul_change (r r' : CosetSection C) (x : K ⧸ C) :
    r.repr x * (r.change r' x : K) = r'.repr x := by
  simp [change]

theorem CosetSection.change_correction (r r' : CosetSection C) (s : K) (x : K ⧸ C) :
    r.change r' (s • x) * r'.correction s x = r.correction s x * r.change r' x := by
  apply Subtype.ext
  simp only [Subgroup.coe_mul, change, correction]
  group

theorem cocycle_change_phase (α : ScalarCocycle K) (s x y c k l c' : K)
    (hc : y * c = s * x) (hk : l * c' = c * k) :
    (α.val y l)⁻¹ * (α.val s (x * k) / α.val (y * l) c') * α.val l c' =
      (α.val s x / α.val y c) * (α.val x k)⁻¹ * α.val c k := by
  have hid : α.val s (x * k) * α.val l c' * (α.val y c * α.val x k) =
      α.val s x * α.val c k * (α.val (y * l) c' * α.val y l) := by
    calc
      _ = α.val l c' * α.val y c * (α.val x k * α.val s (x * k)) := by ac_rfl
      _ = α.val l c' * α.val y c * (α.val s x * α.val (s * x) k) := by
        rw [α.mul_assoc s x k]
      _ = α.val s x * α.val l c' * (α.val y c * α.val (y * c) k) := by
        rw [← hc]
        ac_rfl
      _ = α.val s x * α.val l c' * (α.val c k * α.val y (c * k)) := by
        rw [α.mul_assoc y c k]
      _ = α.val s x * α.val c k * (α.val l c' * α.val y (l * c')) := by
        rw [← hk]
        ac_rfl
      _ = _ := by rw [← α.mul_assoc y l c']; ac_rfl
  have hr := div_eq_div_iff_mul_eq_mul.mpr hid
  convert hr using 1 <;> simp only [div_eq_mul_inv, mul_inv_rev, mul_comm, mul_left_comm, mul_assoc]

def CosetSection.changeUnitary (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (x : K ⧸ C) : V ≃ₗᵢ[ℂ] V :=
  (γ.unitary (r.change r' x)).trans
    (circleUnitary (α.val (r.repr x) (r.change r' x))⁻¹)

@[simp] theorem CosetSection.changeUnitary_apply (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (x : K ⧸ C) (v : V) :
    r.changeUnitary r' α γ x v = ((α.val (r.repr x) (r.change r' x))⁻¹ : Circle) •
      γ.unitary (r.change r' x) v := rfl

theorem CosetSection.change_phase (r r' : CosetSection C) (α : ScalarCocycle K)
    (s : K) (x : K ⧸ C) :
    (α.val (r.repr (s • x)) (r.change r' (s • x)))⁻¹ * r'.phase α s x *
        α.val (r.change r' (s • x)) (r'.correction s x) =
      r.phase α s x * (α.val (r.repr x) (r.change r' x))⁻¹ *
        α.val (r.correction s x) (r.change r' x) := by
  have h := cocycle_change_phase α s (r.repr x) (r.repr (s • x))
    (r.correction s x) (r.change r' x) (r.change r' (s • x)) (r'.correction s x)
    (r.repr_mul_correction s x) (congrArg Subtype.val (r.change_correction r' s x))
  simpa only [phase, repr_mul_change] using h

theorem CosetSection.changeUnitary_intertwines (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (s : K) (x : K ⧸ C) (v : V) :
    r.changeUnitary r' α γ (s • x) (r'.inducedUnitary α γ s x v) =
      r.inducedUnitary α γ s x (r.changeUnitary r' α γ x v) := by
  change ((α.val (r.repr (s • x)) (r.change r' (s • x)))⁻¹ : Circle) •
    γ.unitary (r.change r' (s • x)) ((r'.phase α s x : ℂ) • γ.unitary (r'.correction s x) v) =
    (r.phase α s x : ℂ) • γ.unitary (r.correction s x)
      (((α.val (r.repr x) (r.change r' x))⁻¹ : Circle) • γ.unitary (r.change r' x) v)
  simp only [Circle.smul_def, map_smul, γ.mul, smul_smul]
  rw [change_correction]
  congr 1
  have hp := congrArg (fun z : Circle => (z : ℂ)) (r.change_phase r' α s x)
  simpa only [Circle.coe_mul, ScalarCocycle.restrict, mul_assoc] using hp

end ExactInduction

noncomputable section InducedBundle

attribute [local instance] Classical.propDecidable

variable {K : Type*} [Group K] {C : Subgroup K}
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]

local instance : DecidableEq (K ⧸ C) := Classical.decEq _

def CosetSection.inducedFibreSystem (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) :
    FibreSystem α (fun _ : K ⧸ C => V) where
  unitary s x _ _ := r.inducedUnitary α γ s x
  one x v := r.inducedUnitary_one α γ x v
  mul s t x y z hy hz hst v := by
    subst y
    exact r.inducedUnitary_mul α γ s t x v

def CosetSection.inducedBundle (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) :
    ProjectiveBundle α (fun _ : K ⧸ C => V) :=
  (r.inducedFibreSystem α γ).toBundle

theorem CosetSection.inducedBundle_single (r : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (s : K) (x : K ⧸ C) (v : V) :
    (r.inducedBundle α γ).action s (lp.single 2 x v) =
      lp.single 2 (s • x) ((r.phase α s x : ℂ) • γ.unitary (r.correction s x) v) := by
  exact (r.inducedBundle α γ).action_single s x (s • x) rfl v

def CosetSection.changeBundleUnitary (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) :
    lp (fun _ : K ⧸ C => V) 2 ≃ₗᵢ[ℂ] lp (fun _ : K ⧸ C => V) 2 :=
  relabel (Equiv.refl _) (fun x _ _ => r.changeUnitary r' α γ x)

@[simp] theorem CosetSection.changeBundleUnitary_single (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) (x : K ⧸ C) (v : V) :
    r.changeBundleUnitary r' α γ (lp.single 2 x v) =
      lp.single 2 x (r.changeUnitary r' α γ x v) := by
  exact relabel_single (Equiv.refl _) (fun x _ _ => r.changeUnitary r' α γ x) x x rfl v

theorem CosetSection.changeBundleUnitary_intertwines (r r' : CosetSection C) (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) :
    Intertwines (r'.inducedBundle α γ) (r.inducedBundle α γ)
      (r.changeBundleUnitary r' α γ).toContinuousLinearEquiv.toContinuousLinearMap := by
  intro s v
  have he :
      (r.changeBundleUnitary r' α γ).toContinuousLinearEquiv.toContinuousLinearMap.comp
        ((r'.inducedBundle α γ).action s).toContinuousLinearEquiv.toContinuousLinearMap =
      ((r.inducedBundle α γ).action s).toContinuousLinearEquiv.toContinuousLinearMap.comp
        (r.changeBundleUnitary r' α γ).toContinuousLinearEquiv.toContinuousLinearMap := by
    apply lp.ext_continuousLinearMap (by norm_num)
    intro x
    apply ContinuousLinearMap.ext
    intro w
    change r.changeBundleUnitary r' α γ ((r'.inducedBundle α γ).action s (lp.single 2 x w)) =
      (r.inducedBundle α γ).action s (r.changeBundleUnitary r' α γ (lp.single 2 x w))
    rw [(r'.inducedBundle α γ).action_single s x (s • x) rfl,
      changeBundleUnitary_single, changeBundleUnitary_single,
      (r.inducedBundle α γ).action_single s x (s • x) rfl]
    exact congrArg (lp.single 2 (s • x)) (r.changeUnitary_intertwines r' α γ s x w)
  exact DFunLike.congr_fun he v

theorem exact_projective_induction (α : ScalarCocycle K)
    (γ : ProjectiveRepresentation (α.restrict C) V) :
    (∃ B : ProjectiveBundle α (fun _ : K ⧸ C => V),
      ∀ s x v, B.action s (lp.single 2 x v) =
        lp.single 2 (s • x) (((chooseCosetSection C).phase α s x : ℂ) •
          γ.unitary ((chooseCosetSection C).correction s x) v)) ∧
    ∀ r r' : CosetSection C,
      Intertwines (r'.inducedBundle α γ) (r.inducedBundle α γ)
        (r.changeBundleUnitary r' α γ).toContinuousLinearEquiv.toContinuousLinearMap := by
  refine ⟨⟨(chooseCosetSection C).inducedBundle α γ, ?_⟩, ?_⟩
  · exact (chooseCosetSection C).inducedBundle_single α γ
  · exact fun r r' => r.changeBundleUnitary_intertwines r' α γ

end InducedBundle

end GermBundles

end OAI