/-
Port of `Lattice/IterProd.agda`: the `k`-fold product `A × (A × ⋯ × B)`.

With propositional equality and typeclasses, the Agda `Everything` record
(which threaded the lattice operations and the conditional fixed-height proof
through one recursion, so that the operations built by separate recursions
would agree) is no longer needed: the `Lattice` instance is one recursive
definition, and the fixed-height structure is another recursion over it.

Correspondence:
  IterProd            ↦ Spa.IterProd
  build               ↦ Spa.IterProd.build
  isLattice/lattice   ↦ instance Spa.IterProd.instLattice
  fixedHeight,
  isFiniteHeightLattice,
  finiteHeightLattice ↦ Spa.IterProd.fixedHeight (+ FiniteHeightLattice instance)
  ⊥-built             ↦ Spa.IterProd.bot_fixedHeight
-/
import Spa.Lattice.Prod
import Spa.Lattice.Unit
import Mathlib.Tactic.Ring

namespace Spa

universe u

/-- Agda: `IterProd k = iterate k (A × ·) B`. (As in the Agda module, `A` and
`B` are constrained to the same universe to keep the recursion simple.) -/
def IterProd (A B : Type u) : ℕ → Type u
  | 0 => B
  | k + 1 => A × IterProd A B k

namespace IterProd

variable {A B : Type u}

instance instLattice [Lattice A] [Lattice B] :
    ∀ k, Lattice (IterProd A B k)
  | 0 => inferInstanceAs (Lattice B)
  | k + 1 => @Prod.instLattice A (IterProd A B k) _ (instLattice k)

instance instDecidableEq [DecidableEq A] [DecidableEq B] :
    ∀ k, DecidableEq (IterProd A B k)
  | 0 => inferInstanceAs (DecidableEq B)
  | k + 1 => @instDecidableEqProd A (IterProd A B k) _ (instDecidableEq k)

/-- Agda: `build`. -/
def build (a : A) (b : B) : (k : ℕ) → IterProd A B k
  | 0 => b
  | k + 1 => (a, build a b k)

variable [Lattice A] [Lattice B]

/-- Agda: `fixedHeight` (the `isFiniteHeightIfSupported` recursion). -/
def fixedHeight {hA hB : ℕ} (fhA : FixedHeight A hA) (fhB : FixedHeight B hB) :
    (k : ℕ) → FixedHeight (IterProd A B k) (k * hA + hB)
  | 0 => fhB.cast (by ring)
  | k + 1 => (fhA.prod (fixedHeight fhA fhB k)).cast (by ring)

/-- Agda: `⊥-built` — the bottom of the iterated product is built from the
component bottoms. -/
theorem bot_fixedHeight {hA hB : ℕ} (fhA : FixedHeight A hA) (fhB : FixedHeight B hB) :
    ∀ k, (fixedHeight fhA fhB k).bot = build fhA.bot fhB.bot k
  | 0 => rfl
  | k + 1 => by
    show (fhA.bot, (fixedHeight fhA fhB k).bot) = (fhA.bot, build fhA.bot fhB.bot k)
    rw [bot_fixedHeight fhA fhB k]

instance [IA : FiniteHeightLattice A] [IB : FiniteHeightLattice B] (k : ℕ) :
    FiniteHeightLattice (IterProd A B k) where
  height := k * IA.height + IB.height
  fixedHeight := fixedHeight IA.fixedHeight IB.fixedHeight k

end IterProd

end Spa
