Datasets:

roseking
/

openAI-math-dataset

import OAI.Algebra.DepthFive.GateSums

namespace OAI

open scoped BigOperators
noncomputable section

namespace Problem335

/-- Finite subadditivity, with no assumptions on the individual summands. -/
theorem measure_finset_sum_le {A ι : Type*} [AddCommMonoid A]
    (R : A → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (s : Finset ι) (f : ι → A) :
    R (∑ j ∈ s, f j) ≤ ∑ j ∈ s, R (f j) := by
  classical
  induction s using Finset.induction with
  | empty => simp [hzero]
  | @insert j s hj ih =>
      rw [Finset.sum_insert hj, Finset.sum_insert hj]
      exact (hadd _ _).trans (add_le_add le_rfl ih)

/-- Scalar weighting cannot increase a subadditive rank-like measure. -/
theorem measure_weighted_sum_le {K σ ι : Type*} [CommSemiring K]
    (R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K) :
    R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤ ∑ j ∈ s, R (p j) := by
  exact (measure_finset_sum_le R hzero hadd s _).trans
    (Finset.sum_le_sum (fun j _ => hscale (a j) (p j)))

/-- Expand one selected factor and leave all other occurrences unchanged.
This is the algebraic step behind the high-degree-factor case: in particular,
other occurrences of the very same middle gate are not expanded. -/
theorem measure_one_factor_expansion_le {K σ ι : Type*} [CommSemiring K]
    (R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K)
    (before after : MvPolynomial σ K) :
    R (before * (∑ j ∈ s, MvPolynomial.C (a j) * p j) * after) ≤
      ∑ j ∈ s, R (before * p j * after) := by
  have heq :
      before * (∑ j ∈ s, MvPolynomial.C (a j) * p j) * after =
        ∑ j ∈ s, MvPolynomial.C (a j) * (before * p j * after) := by
    rw [Finset.mul_sum, Finset.sum_mul]
    apply Finset.sum_congr rfl
    intro j hj
    ring
  rw [heq]
  exact measure_weighted_sum_le R hzero hadd hscale s a _

/-- Only predecessors with nonzero aggregate coefficient need a bound.
This matters for homogeneous circuits, since inactive gates can have arbitrary
formal degree. -/
theorem measure_weighted_sum_le_card_mul {K σ ι : Type*} [CommSemiring K]
    (R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K)
    (B : ℝ) (hB : 0 ≤ B)
    (hbound : ∀ j ∈ s, a j ≠ 0 → R (p j) ≤ B) :
    R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤ (s.card : ℝ) * B := by
  calc
    R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤
        ∑ j ∈ s, R (MvPolynomial.C (a j) * p j) :=
      measure_finset_sum_le R hzero hadd s _
    _ ≤ ∑ j ∈ s, B := by
      apply Finset.sum_le_sum
      intro j hj
      by_cases ha : a j = 0
      · simpa [ha, hzero] using hB
      · exact (hscale _ _).trans (hbound j hj ha)
    _ = (s.card : ℝ) * B := by simp

/-- A uniform bound on active output predecessors costs the number of upper
product gates, never the number of output wires. -/
theorem circuit_measure_le_upperCount_mul {K : Type*} [CommSemiring K] {n : ℕ}
    (c : Depth5Circuit K n)
    (R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (B : ℝ) (hB : 0 ≤ B)
    (hbound : ∀ j, gateCoefficient c.outputInputs j ≠ 0 → R (upperValue c j) ≤ B) :
    R (circuitValue c) ≤ (c.upperCount : ℝ) * B := by
  rw [circuitValue_eq_sum]
  simpa using measure_weighted_sum_le_card_mul R hzero hadd hscale
    Finset.univ (gateCoefficient c.outputInputs) (upperValue c) B hB
    (fun j _ => hbound j)

/-- Expanding one middle-gate occurrence costs at most the number of lower
product gates. All other occurrences, including shared copies of the selected
gate, are retained as factors in `before` and `after`. -/
theorem upper_measure_le_lowerCount_mul_of_split
    {K : Type*} [CommSemiring K] {n : ℕ} (c : Depth5Circuit K n)
    (R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (u : Fin c.upperCount) (j : Fin c.middleCount)
    (before after : List (Fin c.middleCount))
    (hsplit : c.upperInputs u = before ++ j :: after)
    (B : ℝ) (hB : 0 ≤ B)
    (hbound : ∀ l, gateCoefficient (c.middleInputs j) l ≠ 0 →
      R ((before.map (middleValue c)).prod * lowerValue c l *
        (after.map (middleValue c)).prod) ≤ B) :
    R (upperValue c u) ≤ (c.lowerCount : ℝ) * B := by
  classical
  have heq : upperValue c u =
      ∑ l : Fin c.lowerCount,
        MvPolynomial.C (gateCoefficient (c.middleInputs j) l) *
          ((before.map (middleValue c)).prod * lowerValue c l *
            (after.map (middleValue c)).prod) := by
    unfold upperValue
    rw [hsplit]
    simp only [List.map_append, List.map_cons, List.prod_append, List.prod_cons]
    rw [middleValue_eq_sum, Finset.sum_mul, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro l hl
    ring
  rw [heq]
  simpa using measure_weighted_sum_le_card_mul R hzero hadd hscale
    Finset.univ (gateCoefficient (c.middleInputs j))
    (fun l => (before.map (middleValue c)).prod * lowerValue c l *
      (after.map (middleValue c)).prod) B hB (fun l _ => hbound l)

/-- The gate-count assembly step in the depth-five rank upper bound.
Each active upper product is either bounded directly, or one occurrence can
be expanded into active lower products with the same bound. -/
theorem circuit_measure_le_size_sq_mul_of_low_or_split
    {K : Type*} [CommSemiring K] {n : ℕ} (c : Depth5Circuit K n)
    (R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
    (hadd : ∀ x y, R (x + y) ≤ R x + R y)
    (hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
    (B : ℝ) (hB : 0 ≤ B)
    (hupper : ∀ u, gateCoefficient c.outputInputs u ≠ 0 →
      R (upperValue c u) ≤ B ∨
        ∃ (j : Fin c.middleCount) (before after : List (Fin c.middleCount)),
          c.upperInputs u = before ++ j :: after ∧
          ∀ l, gateCoefficient (c.middleInputs j) l ≠ 0 →
            R ((before.map (middleValue c)).prod * lowerValue c l *
              (after.map (middleValue c)).prod) ≤ B) :
    R (circuitValue c) ≤ (circuitSize c : ℝ) ^ 2 * B := by
  have honeNat : 1 ≤ circuitSize c := by unfold circuitSize; omega
  have hlowerNat : c.lowerCount ≤ circuitSize c := by unfold circuitSize; omega
  have hupperNat : c.upperCount ≤ circuitSize c := by unfold circuitSize; omega
  have hone : (1 : ℝ) ≤ circuitSize c := by exact_mod_cast honeNat
  have hlower : (c.lowerCount : ℝ) ≤ circuitSize c := by exact_mod_cast hlowerNat
  have hupperCount : (c.upperCount : ℝ) ≤ circuitSize c := by exact_mod_cast hupperNat
  have hSB : 0 ≤ (circuitSize c : ℝ) * B := mul_nonneg (Nat.cast_nonneg _) hB
  have hgates : ∀ u, gateCoefficient c.outputInputs u ≠ 0 →
      R (upperValue c u) ≤ (circuitSize c : ℝ) * B := by
    intro u hu
    rcases hupper u hu with hlow | ⟨j, before, after, hsplit, hbound⟩
    · exact hlow.trans (by nlinarith)
    · exact (upper_measure_le_lowerCount_mul_of_split c R hzero hadd hscale
        u j before after hsplit B hB hbound).trans (mul_le_mul_of_nonneg_right hlower hB)
  calc
    R (circuitValue c) ≤ (c.upperCount : ℝ) * ((circuitSize c : ℝ) * B) :=
      circuit_measure_le_upperCount_mul c R hzero hadd hscale _ hSB hgates
    _ ≤ (circuitSize c : ℝ) * ((circuitSize c : ℝ) * B) :=
      mul_le_mul_of_nonneg_right hupperCount hSB
    _ = (circuitSize c : ℝ) ^ 2 * B := by ring

end Problem335

end

end OAI

	import OAI.Algebra.DepthFive.GateSums

	namespace OAI

	open scoped BigOperators
	noncomputable section

	namespace Problem335

	/-- Finite subadditivity, with no assumptions on the individual summands. -/
	theorem measure_finset_sum_le {A ι : Type*} [AddCommMonoid A]
	(R : A → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(s : Finset ι) (f : ι → A) :
	R (∑ j ∈ s, f j) ≤ ∑ j ∈ s, R (f j) := by
	classical
	induction s using Finset.induction with
	\| empty => simp [hzero]
	\| @insert j s hj ih =>
	rw [Finset.sum_insert hj, Finset.sum_insert hj]
	exact (hadd _ _).trans (add_le_add le_rfl ih)

	/-- Scalar weighting cannot increase a subadditive rank-like measure. -/
	theorem measure_weighted_sum_le {K σ ι : Type*} [CommSemiring K]
	(R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K) :
	R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤ ∑ j ∈ s, R (p j) := by
	exact (measure_finset_sum_le R hzero hadd s _).trans
	(Finset.sum_le_sum (fun j _ => hscale (a j) (p j)))

	/-- Expand one selected factor and leave all other occurrences unchanged.
	This is the algebraic step behind the high-degree-factor case: in particular,
	other occurrences of the very same middle gate are not expanded. -/
	theorem measure_one_factor_expansion_le {K σ ι : Type*} [CommSemiring K]
	(R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K)
	(before after : MvPolynomial σ K) :
	R (before * (∑ j ∈ s, MvPolynomial.C (a j) * p j) * after) ≤
	∑ j ∈ s, R (before * p j * after) := by
	have heq :
	before * (∑ j ∈ s, MvPolynomial.C (a j) * p j) * after =
	∑ j ∈ s, MvPolynomial.C (a j) * (before * p j * after) := by
	rw [Finset.mul_sum, Finset.sum_mul]
	apply Finset.sum_congr rfl
	intro j hj
	ring
	rw [heq]
	exact measure_weighted_sum_le R hzero hadd hscale s a _

	/-- Only predecessors with nonzero aggregate coefficient need a bound.
	This matters for homogeneous circuits, since inactive gates can have arbitrary
	formal degree. -/
	theorem measure_weighted_sum_le_card_mul {K σ ι : Type*} [CommSemiring K]
	(R : MvPolynomial σ K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(s : Finset ι) (a : ι → K) (p : ι → MvPolynomial σ K)
	(B : ℝ) (hB : 0 ≤ B)
	(hbound : ∀ j ∈ s, a j ≠ 0 → R (p j) ≤ B) :
	R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤ (s.card : ℝ) * B := by
	calc
	R (∑ j ∈ s, MvPolynomial.C (a j) * p j) ≤
	∑ j ∈ s, R (MvPolynomial.C (a j) * p j) :=
	measure_finset_sum_le R hzero hadd s _
	_ ≤ ∑ j ∈ s, B := by
	apply Finset.sum_le_sum
	intro j hj
	by_cases ha : a j = 0
	· simpa [ha, hzero] using hB
	· exact (hscale _ _).trans (hbound j hj ha)
	_ = (s.card : ℝ) * B := by simp

	/-- A uniform bound on active output predecessors costs the number of upper
	product gates, never the number of output wires. -/
	theorem circuit_measure_le_upperCount_mul {K : Type*} [CommSemiring K] {n : ℕ}
	(c : Depth5Circuit K n)
	(R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(B : ℝ) (hB : 0 ≤ B)
	(hbound : ∀ j, gateCoefficient c.outputInputs j ≠ 0 → R (upperValue c j) ≤ B) :
	R (circuitValue c) ≤ (c.upperCount : ℝ) * B := by
	rw [circuitValue_eq_sum]
	simpa using measure_weighted_sum_le_card_mul R hzero hadd hscale
	Finset.univ (gateCoefficient c.outputInputs) (upperValue c) B hB
	(fun j _ => hbound j)

	/-- Expanding one middle-gate occurrence costs at most the number of lower
	product gates. All other occurrences, including shared copies of the selected
	gate, are retained as factors in `before` and `after`. -/
	theorem upper_measure_le_lowerCount_mul_of_split
	{K : Type*} [CommSemiring K] {n : ℕ} (c : Depth5Circuit K n)
	(R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(u : Fin c.upperCount) (j : Fin c.middleCount)
	(before after : List (Fin c.middleCount))
	(hsplit : c.upperInputs u = before ++ j :: after)
	(B : ℝ) (hB : 0 ≤ B)
	(hbound : ∀ l, gateCoefficient (c.middleInputs j) l ≠ 0 →
	R ((before.map (middleValue c)).prod * lowerValue c l *
	(after.map (middleValue c)).prod) ≤ B) :
	R (upperValue c u) ≤ (c.lowerCount : ℝ) * B := by
	classical
	have heq : upperValue c u =
	∑ l : Fin c.lowerCount,
	MvPolynomial.C (gateCoefficient (c.middleInputs j) l) *
	((before.map (middleValue c)).prod * lowerValue c l *
	(after.map (middleValue c)).prod) := by
	unfold upperValue
	rw [hsplit]
	simp only [List.map_append, List.map_cons, List.prod_append, List.prod_cons]
	rw [middleValue_eq_sum, Finset.sum_mul, Finset.mul_sum]
	apply Finset.sum_congr rfl
	intro l hl
	ring
	rw [heq]
	simpa using measure_weighted_sum_le_card_mul R hzero hadd hscale
	Finset.univ (gateCoefficient (c.middleInputs j))
	(fun l => (before.map (middleValue c)).prod * lowerValue c l *
	(after.map (middleValue c)).prod) B hB (fun l _ => hbound l)

	/-- The gate-count assembly step in the depth-five rank upper bound.
	Each active upper product is either bounded directly, or one occurrence can
	be expanded into active lower products with the same bound. -/
	theorem circuit_measure_le_size_sq_mul_of_low_or_split
	{K : Type*} [CommSemiring K] {n : ℕ} (c : Depth5Circuit K n)
	(R : MvPolynomial (Fin n × Fin n × Fin n) K → ℝ) (hzero : R 0 = 0)
	(hadd : ∀ x y, R (x + y) ≤ R x + R y)
	(hscale : ∀ a p, R (MvPolynomial.C a * p) ≤ R p)
	(B : ℝ) (hB : 0 ≤ B)
	(hupper : ∀ u, gateCoefficient c.outputInputs u ≠ 0 →
	R (upperValue c u) ≤ B ∨
	∃ (j : Fin c.middleCount) (before after : List (Fin c.middleCount)),
	c.upperInputs u = before ++ j :: after ∧
	∀ l, gateCoefficient (c.middleInputs j) l ≠ 0 →
	R ((before.map (middleValue c)).prod * lowerValue c l *
	(after.map (middleValue c)).prod) ≤ B) :
	R (circuitValue c) ≤ (circuitSize c : ℝ) ^ 2 * B := by
	have honeNat : 1 ≤ circuitSize c := by unfold circuitSize; omega
	have hlowerNat : c.lowerCount ≤ circuitSize c := by unfold circuitSize; omega
	have hupperNat : c.upperCount ≤ circuitSize c := by unfold circuitSize; omega
	have hone : (1 : ℝ) ≤ circuitSize c := by exact_mod_cast honeNat
	have hlower : (c.lowerCount : ℝ) ≤ circuitSize c := by exact_mod_cast hlowerNat
	have hupperCount : (c.upperCount : ℝ) ≤ circuitSize c := by exact_mod_cast hupperNat
	have hSB : 0 ≤ (circuitSize c : ℝ) * B := mul_nonneg (Nat.cast_nonneg _) hB
	have hgates : ∀ u, gateCoefficient c.outputInputs u ≠ 0 →
	R (upperValue c u) ≤ (circuitSize c : ℝ) * B := by
	intro u hu
	rcases hupper u hu with hlow \| ⟨j, before, after, hsplit, hbound⟩
	· exact hlow.trans (by nlinarith)
	· exact (upper_measure_le_lowerCount_mul_of_split c R hzero hadd hscale
	u j before after hsplit B hB hbound).trans (mul_le_mul_of_nonneg_right hlower hB)
	calc
	R (circuitValue c) ≤ (c.upperCount : ℝ) * ((circuitSize c : ℝ) * B) :=
	circuit_measure_le_upperCount_mul c R hzero hadd hscale _ hSB hgates
	_ ≤ (circuitSize c : ℝ) * ((circuitSize c : ℝ) * B) :=
	mul_le_mul_of_nonneg_right hupperCount hSB
	_ = (circuitSize c : ℝ) ^ 2 * B := by ring

	end Problem335

	end

	end OAI