import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Data.Fintype.Powerset
import Mathlib.Data.Nat.Cast.Order.Field
import Mathlib.Order.Filter.AtTopBot.Basic
import OAI.Combinatorics.BalancedRyser.Construction.Construction

namespace OAI

namespace Balanced.Local

open scoped BigOperators
open Filter

universe u

noncomputable section
attribute [local instance] Classical.propDecidable

abbrev TupleCode (F : Type u) := (Fin 4 → Direction F) × (Fin 4 → Bool)

abbrev ChoiceCode (F : Type u) := Line F × TupleCode F
abbrev Output (F : Type u) := Slot F → ChoiceCode F

def decodeTuple {F : Type u} (t : TupleCode F) : FourTuple F := ⟨t.1, t.2⟩
def decodeChoice {F : Type u} (c : ChoiceCode F) : SplitChoice F :=
  ⟨c.1, decodeTuple c.2⟩
def configuration {F : Type u} (M : MergedPairs F) (v : Output F) : Configuration F :=
  ⟨M, fun s => decodeChoice (v s)⟩

variable {F : Type u} [Field F] [Fintype F] [DecidableEq F]

def constituentMultiplicity (M : MergedPairs F) (p : Point F) : ℕ :=
  (Finset.univ.filter (fun ds : Direction F × Bool =>
    OnLine p (constituent M ds.1 ds.2))).card

def logBudget (F : Type u) [Fintype F] : ℕ := Nat.ceil (Real.log (Fintype.card F))

def offsetProbability (E : MergedPairs F → Prop) : ℝ :=
  (∑ M : MergedPairs F, if E M then (1 : ℝ) else 0) /
    Fintype.card (MergedPairs F)

def conditionedOffsetProbability (A E : MergedPairs F → Prop) : ℝ :=
  offsetProbability (fun M => A M ∧ E M) / offsetProbability A

structure RetentionRule (F : Type u) [Field F] [Fintype F] [DecidableEq F] where
  candidates : MergedPairs F → Direction F → Finset (ChoiceCode F)
  valid : ∀ M g c, c ∈ candidates M g → ValidChoice M g (decodeChoice c)
  uniqueLine : ∀ M g c d, c ∈ candidates M g → d ∈ candidates M g →
    c.1 = d.1 → c = d
  complete : ∀ M g c, ValidChoice M g (decodeChoice c) →
    ∃ d ∈ candidates M g, d.1 = c.1

abbrev Kernel (F : Type u) := MergedPairs F → Output F → ℝ

def KernelConditions (Q : RetentionRule F) (w : Kernel F) (K : ℝ) : Prop :=
  (∀ M v, 0 ≤ w M v) ∧
  (∀ M, ∑ v, w M v ≤ 1) ∧
  (∀ M v, 0 < w M v →
    (configuration M v).Valid ∧ (configuration M v).Compatible ∧
    (∀ s, v s ∈ Q.candidates M s.1) ∧
    (∀ p, constituentMultiplicity M p ≤ logBudget F)) ∧
  (∀ M (S : Finset (Slot F)) (t : Slot F → TupleCode F),
    (∑ v, if (∀ s ∈ S, (v s).2 = t s) then w M v else 0) ≤
      (K / Fintype.card F) ^ S.card)

def selectedProbability (w : Kernel F) (E : Configuration F → Prop) : ℝ :=
  (∑ M : MergedPairs F, ∑ v : Output F,
    if E (configuration M v) then w M v else 0) /
      Fintype.card (MergedPairs F)

def generatorUnionAt (C : Configuration F) (p : Point F) : Finset (Direction F) :=
  (Finset.univ.filter (fun s => OnLine p (C.choice s).line)).biUnion
    (fun s => generatorSet (C.choice s).tuple)

def reuseCount (C : Configuration F) (p : Point F) : ℕ :=
  4 * C.splitMultiplicity p - (generatorUnionAt C p).card

structure EqualityPattern (b κ : ℕ) where
  classOf : Fin b → Fin 4 → Fin (4 * b - κ)
  everyClass : Function.Surjective (fun ij : Fin b × Fin 4 => classOf ij.1 ij.2)
  withinTuple : ∀ i, Function.Injective (classOf i)
  pairOverlap : ∀ i j, i ≠ j →
    ((Finset.univ.image (classOf i)) ∩ (Finset.univ.image (classOf j))).card ≤ 1

abbrev DirectionAssignment (F : Type u) (b κ : ℕ) :=
  (Fin b → Direction F) × (Fin (4 * b - κ) → Direction F)
abbrev Bits (b : ℕ) := Fin b → Fin 4 → Bool

def Eligible {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) : Prop :=
  Function.Injective a.1 ∧ Function.Injective a.2 ∧
    ∀ i j, a.2 (P.classOf i j) ≠ a.1 i

def prescribedTuple {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (i : Fin b) : FourTuple F :=
  ⟨fun j => a.2 (P.classOf i j), bits i⟩

def prescribedPoint {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b)
    (M : MergedPairs F) (ij : Fin b × Fin 4) : Point F :=
  tuplePoint M (prescribedTuple P a bits ij.1) ij.2

def Aligned {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (p : Point F)
    (M : MergedPairs F) : Prop :=
  ∀ ij, OnLine (prescribedPoint P a bits M ij) (lineThrough (a.1 ij.1) p)

def Admissible {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (p : Point F)
    (M : MergedPairs F) : Prop :=
  Aligned P a bits p M ∧ Function.Injective (prescribedPoint P a bits M) ∧
    (∀ ij, prescribedPoint P a bits M ij ≠ p) ∧
    (∀ i, lineThrough (a.1 i) p ∉ constituentLines M) ∧
    (∀ x, constituentMultiplicity M x ≤ logBudget F)

def prescribedDesignated {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (M : MergedPairs F) :
    Finset (Point F) := Finset.univ.image (prescribedPoint P a bits M)

def prescribedPartners {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (p : Point F)
    (M : MergedPairs F) : Finset (Point F) :=
  (prescribedDesignated P a bits M).filter (fun x =>
    ∃ ds : Direction F × Bool, OnLine p (constituent M ds.1 ds.2) ∧
      OnLine x (constituent M ds.1 (!ds.2)))

def piecePoints (M : MergedPairs F) : LocalPiece F → Finset (Point F)
  | Sum.inl U => U
  | Sum.inr (Sum.inl l) => linePoints l
  | Sum.inr (Sum.inr d) => mergedPoints M d

def AllowedPiece {b κ : ℕ} (a : DirectionAssignment F b κ) (p : Point F)
    (M : MergedPairs F) : LocalPiece F → Prop
  | Sum.inl U => U.card ≤ 2
  | Sum.inr (Sum.inl l) =>
      l ∉ (Finset.univ.image (fun i => lineThrough (a.1 i) p)) ∪ constituentLines M
  | Sum.inr (Sum.inr _) => True

def BadCover {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (p : Point F)
    (M : MergedPairs F) : Prop :=
  ∃ A : Finset (LocalPiece F), A.card ≤ b - 1 ∧
    (∀ x ∈ A, AllowedPiece a p M x) ∧
    prescribedDesignated P a bits M ⊆
      prescribedPartners P a bits p M ∪ A.biUnion (piecePoints M)

def AdmissibleBadCover {b κ : ℕ} (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (bits : Bits b) (p : Point F)
    (M : MergedPairs F) : Prop :=
  Admissible P a bits p M ∧ BadCover P a bits p M

def PencilLocalResult : Prop :=
  ∀ K : ℝ, 0 < K → ∃ ε : ℕ → ℝ,
    Tendsto ε atTop (nhds 0) ∧ (∀ q, 0 ≤ ε q) ∧
    ∃ q₀ : ℕ, ∀ (F : Type u) [Field F] [Fintype F] [DecidableEq F],
      q₀ ≤ Fintype.card F → ∀ (Q : RetentionRule F) (w : Kernel F),
      KernelConditions Q w K →
      selectedProbability w (fun C => ¬ C.LocalCondition) ≤ ε (Fintype.card F)

def PencilReuseResult : Prop :=
  ∀ K : ℝ, 0 < K → ∃ C : ℝ, 0 < C ∧ ∃ q₀ : ℕ,
    ∀ (F : Type u) [Field F] [Fintype F] [DecidableEq F],
      q₀ ≤ Fintype.card F → ∀ (Q : RetentionRule F) (w : Kernel F),
      KernelConditions Q w K → ∀ p : Point F,
      selectedProbability w (fun X => 2 ≤ X.splitMultiplicity p ∧ 3 ≤ reuseCount X p) ≤
        C / (Fintype.card F : ℝ) ^ 3

def AlignmentNormalizationResult : Prop :=
  ∀ (F : Type u) [Field F] [Fintype F] [DecidableEq F],
    ∀ b κ : ℕ, 3 ≤ b → b ≤ logBudget F → κ ≤ 2 →
    ∀ (P : EqualityPattern b κ) (a : DirectionAssignment F b κ), Eligible P a →
    ∀ (bits : Bits b) (p : Point F),
      offsetProbability (Aligned P a bits p) = 1 / (Fintype.card F : ℝ) ^ (4 * b)

def PencilSmallReuseResult : Prop :=
  AlignmentNormalizationResult.{u} ∧
  ∃ C : ℝ, 0 < C ∧ ∃ d q₀ : ℕ,
    ∀ (F : Type u) [Field F] [Fintype F] [DecidableEq F],
      q₀ ≤ Fintype.card F → ∀ b κ : ℕ, 3 ≤ b → b ≤ logBudget F → κ ≤ 1 →
      ∀ (P : EqualityPattern b κ) (a : DirectionAssignment F b κ), Eligible P a →
      ∀ (bits : Bits b) (p : Point F),
      conditionedOffsetProbability (Aligned P a bits p) (AdmissibleBadCover P a bits p) ≤
        C * (b : ℝ) ^ d * (2 * (logBudget F : ℝ) / Fintype.card F) ^ (3 - κ)

def PencilTwoReusesResult : Prop :=
  ∃ C : ℝ, 0 < C ∧ ∃ q₀ : ℕ,
    ∀ (F : Type u) [Field F] [Fintype F] [DecidableEq F],
      q₀ ≤ Fintype.card F → ∀ b : ℕ, 3 ≤ b → b ≤ logBudget F →
      ∀ (P : EqualityPattern b 2) (bits : Bits b) (p : Point F),
      (∑ a : DirectionAssignment F b 2,
        if Eligible P a then offsetProbability (fun M =>
          Aligned P a bits p M ∧ AdmissibleBadCover P a bits p M) else 0) ≤
        ((Fintype.card F + 1 : ℕ) : ℝ) ^ (5 * b - 2) /
          (Fintype.card F : ℝ) ^ (4 * b) * (C * (b : ℝ) ^ 3 / Fintype.card F)

end
end Balanced.Local

end OAI