import Mathlib.Data.Fintype.EquivFin
import Mathlib.Data.Fintype.Sum
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Logic.Equiv.Sum

namespace OAI
noncomputable section
namespace ExternalTensor.Binomial

/-- A branch records the choices of the two summands during iteration. -/
def Branch : ℕ → Type
  | 0 => Unit
  | n + 1 => Branch n ⊕ Branch n

instance branchFintype : (n : ℕ) → Fintype (Branch n)
  | 0 => inferInstanceAs (Fintype Unit)
  | n + 1 => letI := branchFintype n; inferInstanceAs (Fintype (Branch n ⊕ Branch n))

def weight : {n : ℕ} → Branch n → ℕ
  | 0, _ => 0
  | _ + 1, .inl x => weight x
  | _ + 1, .inr x => weight x + 1

theorem weight_le : ∀ {n : ℕ} (x : Branch n), weight x ≤ n
  | 0, _ => Nat.le_refl _
  | _n + 1, .inl x => Nat.le_succ_of_le (weight_le x)
  | _n + 1, .inr x => Nat.succ_le_succ (weight_le x)

/-- The left branch has weight zero exactly when the old branch does. -/
def zeroFiber (n : ℕ) : {x : Branch (n+1) // weight x = 0} ≃
    {x : Branch n // weight x = 0} where
  toFun x := match x with
    | ⟨.inl x, h⟩ => ⟨x, h⟩
    | ⟨.inr x, h⟩ => False.elim (Nat.noConfusion h)
  invFun x := ⟨.inl x.val, x.property⟩
  left_inv x := by
    rcases x with ⟨x | x, h⟩
    · rfl
    · exact False.elim (Nat.noConfusion h)
  right_inv x := rfl

/-- The two disjoint ways to achieve weight q+1 give Pascal's recurrence. -/
def succFiber (n q : ℕ) : {x : Branch (n+1) // weight x = q+1} ≃
    ({x : Branch n // weight x = q+1} ⊕ {x : Branch n // weight x = q}) where
  toFun x := match x with
    | ⟨.inl x, h⟩ => .inl ⟨x, h⟩
    | ⟨.inr x, h⟩ => .inr ⟨x, Nat.succ.inj h⟩
  invFun x := match x with
    | .inl x => ⟨.inl x.val, x.property⟩
    | .inr x => ⟨.inr x.val, congrArg Nat.succ x.property⟩
  left_inv x := by rcases x with ⟨x | x, h⟩ <;> rfl
  right_inv x := by cases x <;> rfl

theorem card_weight (n q : ℕ) :
    Fintype.card {x : Branch n // weight x = q} = Nat.choose n q := by
  classical
  induction n generalizing q with
  | zero =>
    cases q with
    | zero =>
      let : Unique {x : Branch 0 // weight x = 0} :=
        ⟨⟨⟨(), rfl⟩⟩, fun x => by rcases x with ⟨⟨⟩, h⟩; rfl⟩
      simp
    | succ q =>
      let : IsEmpty {x : Branch 0 // weight x = q+1} :=
        ⟨fun x => Nat.noConfusion x.property⟩
      simp
  | succ n ih =>
    cases q with
    | zero => rw [Fintype.card_congr (zeroFiber n), ih]; simp
    | succ q => rw [Fintype.card_congr (succFiber n q), Fintype.card_sum, ih, ih,
        Nat.choose_succ_succ, Nat.add_comm]

def degree {n : ℕ} (x : Branch n) : Fin (n+1) := ⟨weight x, Nat.lt_succ_of_le (weight_le x)⟩

def degreeFiber (n : ℕ) (q : Fin (n+1)) :
    {x : Branch n // degree x = q} ≃ {x : Branch n // weight x = q.val} :=
  Equiv.subtypeEquivRight (fun _ => Fin.ext_iff)

def fiberFin (n : ℕ) (q : Fin (n+1)) :
    {x : Branch n // degree x = q} ≃ Fin (Nat.choose n q.val) := by
  classical
  exact Fintype.equivFinOfCardEq ((Fintype.card_congr (degreeFiber n q)).trans (card_weight n q))

/-- Group branches by their weight, with the binomial coefficient as the exact fiber size. -/
def groupEquiv (n : ℕ) : Branch n ≃ Σ q : Fin (n+1), Fin (Nat.choose n q.val) :=
  (Equiv.sigmaFiberEquiv (@degree n)).symm.trans (Equiv.sigmaCongrRight (fiberFin n))

@[simp] theorem groupEquiv_fst (n : ℕ) (x : Branch n) :
    (groupEquiv n x).1 = degree x := rfl
end ExternalTensor.Binomial

end

end OAI