math / data /lean /OAI /NumberTheory /PowerFree /RegularBlocks.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
17.1 kB
import OAI.NumberTheory.PowerFree.PrimeBlocks
namespace OAI
open scoped BigOperators
open Matrix
open scoped BigOperators
open scoped BigOperators
namespace QuarticPowerFree
open scoped BigOperators
theorem independent_many_regular {r : β„•} {S : Type*} [Fintype S]
{Ξ© : Fin r β†’ Type*} [βˆ€ i, Fintype (Ξ© i)]
(w : βˆ€ i, Ξ© i β†’ ℝ) (hw : βˆ€ i a, 0 ≀ w i a)
(hsum : βˆ€ i, βˆ‘ a, w i a = 1)
(b : (βˆ€ i, Ξ© i) β†’ S β†’ Fin r β†’ ℝ)
(hb : βˆ€ x z i, 0 ≀ b x z i) (Ξ· ΞΎ : ℝ) (hΞΎ : 0 < ΞΎ)
(hmean : βˆ€ z i x, (βˆ‘ a, w i a * b (Function.update x i a) z i) ≀ Ξ·) :
βˆƒ x : βˆ€ i, Ξ© i,
((Finset.univ.filter fun z : S => βˆ€ i, b x z i ≀ ΞΎ).card : ℝ) β‰₯
(1 - (r : ℝ)*Ξ·/ΞΎ) * Fintype.card S := by
classical
let W : (βˆ€ i, Ξ© i) β†’ ℝ := fun x => ∏ i, w i (x i)
have hW : βˆ€ x, 0 ≀ W x := fun x => Finset.prod_nonneg fun i _ => hw i (x i)
have hsumW : βˆ‘ x, W x = 1 := by
change (βˆ‘ x : βˆ€ i, Ξ© i, ∏ i, w i (x i)) = 1
rw [← Fintype.prod_sum]
simp only [hsum,Finset.prod_const_one]
have hm (z : S) (i : Fin r) : βˆ‘ x, W x * b x z i ≀ Ξ· :=
independent_average_le w hw hsum i (fun x => b x z i) Ξ· (hmean z i)
have hbad (z : S) :
(βˆ‘ x, W x * if βˆƒ i, ΞΎ < b x z i then (1 : ℝ) else 0) ≀ (r : ℝ)*Ξ·/ΞΎ := by
calc
_ ≀ βˆ‘ x, W x * ((βˆ‘ i, b x z i)/ΞΎ) :=
Finset.sum_le_sum fun x _ => mul_le_mul_of_nonneg_left
(bad_blocks_indicator_le (b x z) (hb x z) ΞΎ hΞΎ) (hW x)
_ = (βˆ‘ i, βˆ‘ x, W x * b x z i)/ΞΎ := by
simp_rw [← mul_div_assoc,Finset.mul_sum]
rw [← Finset.sum_div,Finset.sum_comm]
_ ≀ (βˆ‘ _i : Fin r, Ξ·)/ΞΎ := div_le_div_of_nonneg_right
(Finset.sum_le_sum fun i _ => hm z i) hΞΎ.le
_ = (r : ℝ)*Ξ·/ΞΎ := by simp
obtain ⟨x,hx⟩ := exists_many_regular W hW hsumW
(fun x z => βˆƒ i, ΞΎ < b x z i) ((r : ℝ)*Ξ·/ΞΎ) hbad
refine ⟨x,?_⟩
simpa only [not_exists,not_lt] using hx
lemma adaptiveStates_precomp {K V Οƒ Ξ± Ξ² : Type*} [Field K] [AddCommGroup V]
[Module K V] (W : β„• β†’ Οƒ β†’ Ξ± β†’ Submodule K V)
(next : β„• β†’ Οƒ β†’ Submodule K V β†’ Οƒ) (f : Ξ² β†’ Ξ±)
(n i : β„•) (s : Οƒ) (a : Ξ²) :
adaptiveStates (fun j t b => W j t (f b)) next n i s a =
adaptiveStates W next n i s (f a) := by
induction n generalizing i s with
| zero => rfl
| succ n ih => simp only [adaptiveStates,ih]
noncomputable def selectedBlocks {r T : β„•} {P : Fin r β†’ Finset β„•}
{ell : Fin r β†’ β„•} (a : βˆ€ i, BlockSample (P i) (ell i) T) : Fin r β†’ Finset β„• :=
fun i => blockSet (a i)
lemma selectedBlocks_update {r T : β„•} {P : Fin r β†’ Finset β„•}
{ell : Fin r β†’ β„•} (a : βˆ€ i, BlockSample (P i) (ell i) T)
(i : Fin r) (u : BlockSample (P i) (ell i) T) :
selectedBlocks (Function.update a i u) = Function.update (selectedBlocks a) i (blockSet u) := by
funext j
by_cases h : j = i
Β· subst j; simp [selectedBlocks]
Β· simp [selectedBlocks,Function.update_of_ne h]
theorem regular_adaptive_blocks {K V Οƒ S : Type*}
[Field K] [AddCommGroup V] [Module K V] [Module.Finite K V] [Fintype S]
{r : β„•} (P : Fin r β†’ Finset β„•) (ell : Fin r β†’ β„•) (T n : β„•)
(W : S β†’ β„• β†’ Οƒ β†’ (Fin r β†’ Finset β„•) β†’ Submodule K V)
(next : S β†’ β„• β†’ Οƒ β†’ Submodule K V β†’ Οƒ) (start : S β†’ Οƒ)
(minor : S β†’ Οƒ β†’ β„€)
(hW : βˆ€ z j s B i A A', A βŠ† A' β†’
W z j s (Function.update B i A) ≀ W z j s (Function.update B i A'))
(X ΞΆ B Ξ· ΞΎ : ℝ) (hX : 1 < X) (hΞΆ : 0 < ΞΆ) (hΞΎ : 0 < ΞΎ)
(hp : βˆ€ i p, p ∈ P i β†’ p.Prime)
(hsmall : βˆ€ i p, p ∈ P i β†’ X^ΞΆ ≀ (p : ℝ))
(hminor : βˆ€ z A, (βˆ€ i, A i βŠ† P i) β†’
βˆ€ t ∈ adaptiveStates (W z) (next z) n 0 (start z) A,
minor z t β‰  0 ∧ |(minor z t : ℝ)| ≀ X^B)
(hT : 0 < T) (hsize : βˆ€ i, ell i+T < (P i).card)
(hΞ· : βˆ€ i, (((Module.finrank K V+1)^n : β„•) : ℝ)/T +
(⌊(B*(n+1:β„•))/ΞΆβŒ‹β‚Š : ℝ)/(((P i).card : ℝ)-(ell i+T)) ≀ Ξ·) :
βˆƒ A : Fin r β†’ Finset β„•,
(βˆ€ i, A i βŠ† P i ∧ ell i < (A i).card ∧ (A i).card ≀ ell i+T) ∧
((Finset.univ.filter fun z : S => βˆ€ i,
((βˆ‘ p ∈ A i,
if (p : β„€) ∣ ((adaptiveStates (W z) (next z) n 0 (start z) A).map (minor z)).prod
then (1 : ℝ) else 0) / (A i).card) ≀ ΞΎ).card : ℝ) β‰₯
(1-(r : ℝ)*Ξ·/ΞΎ)*Fintype.card S := by
classical
let Ξ© := fun i => BlockSample (P i) (ell i) T
let w : βˆ€ i, Ξ© i β†’ ℝ := fun i => blockWeight (P i) (ell i) T
let M := fun z A => ((adaptiveStates (W z) (next z) n 0 (start z) A).map (minor z)).prod
let b : (βˆ€ i, Ξ© i) β†’ S β†’ Fin r β†’ ℝ := fun a z i =>
(βˆ‘ p ∈ selectedBlocks a i, if (p : β„€) ∣ M z (selectedBlocks a) then (1 : ℝ) else 0) /
(selectedBlocks a i).card
have hb : βˆ€ a z i, 0 ≀ b a z i := by
intro a z i
exact div_nonneg (Finset.sum_nonneg fun p _ => by split_ifs <;> positivity)
(Nat.cast_nonneg _)
have hmean : βˆ€ z i a, (βˆ‘ u, w i u * b (Function.update a i u) z i) ≀ Ξ· := by
intro z i a
let Aβ‚€ := selectedBlocks a
let Wi := fun j s A => W z j s (Function.update Aβ‚€ i A)
let bad : Finset β„• β†’ Finset β„• := fun A => (P i).filter fun p : β„• =>
(p : β„€) ∣ M z (Function.update Aβ‚€ i A)
have hm (A : Finset β„•) (hA : A βŠ† P i) :
βˆ€ t ∈ adaptiveStates Wi (next z) n 0 (start z) A,
minor z t β‰  0 ∧ |(minor z t : ℝ)| ≀ X^B := by
rw [adaptiveStates_precomp]
apply hminor z
intro j
by_cases h : j = i
Β· subst j; simpa using hA
Β· simpa only [Function.update_of_ne h, Aβ‚€, selectedBlocks] using (blockSet_spec (a j)).1
have hdel := adaptive_deletion_bound Wi (next z)
(fun j s A A' hAA' => hW z j s Aβ‚€ i A A' hAA') (minor z) n (start z)
(P i) (hp i) X ΞΆ B hX hΞΆ (hsmall i) hm (ell i) T hT (hsize i)
dsimp only at hdel
simp only [Wi, adaptiveStates_precomp] at hdel
change ((βˆ‘ j ∈ Finset.range T, badFraction (P i) (ell i+j+1) bad) / T) ≀ _ at hdel
have heq : (βˆ‘ u, w i u * b (Function.update a i u) z i) =
(βˆ‘ j ∈ Finset.range T, badFraction (P i) (ell i+j+1) bad) / T := by
rw [← blockWeight_bad_average]
apply Finset.sum_congr rfl
intro u _
dsimp only [w,b]
rw [selectedBlocks_update, Function.update_self]
congr 2
apply Finset.sum_congr rfl
intro p hpU
have hpP := (blockSet_spec u).1 hpU
simp only [bad,Finset.mem_filter,hpP,true_and,Aβ‚€]
rw [heq]
exact hdel.trans (hΞ· i)
obtain ⟨a,ha⟩ := independent_many_regular w
(fun i => blockWeight_nonneg (P i) (ell i) T)
(fun i => blockWeight_sum (P i) (ell i) T hT (hsize i).le)
b hb Ξ· ΞΎ hΞΎ hmean
refine ⟨selectedBlocks a,?_,ha⟩
intro i
obtain ⟨hsub,hcard⟩ := blockSet_spec (a i)
refine ⟨hsub,?_,?_⟩
Β· change ell i < (blockSet (a i)).card
rw [hcard]; omega
Β· change (blockSet (a i)).card ≀ ell i+T
rw [hcard]
have := (a i).1.isLt
omega
open MvPolynomial
noncomputable def cumulativeBlockPrimes {r : β„•} (B : Fin r β†’ Finset β„•) (i : β„•) : Finset β„• :=
(Finset.univ.filter fun j => j.val ≀ i).biUnion B
theorem cumulativeBlockPrimes_mono {r : β„•} {B C : Fin r β†’ Finset β„•}
(hBC : βˆ€ j, B j βŠ† C j) (i : β„•) :
cumulativeBlockPrimes B i βŠ† cumulativeBlockPrimes C i := by
classical
intro p hp
obtain ⟨j,hj,hp⟩ := Finset.mem_biUnion.mp hp
exact Finset.mem_biUnion.mpr ⟨j,hj,hBC j hp⟩
def pathDegreeBudget (n : β„•) (d : β„• β†’ β„•) (A h e : β„•) : β„• β†’ β„•
| 0 => e
| i+1 => patchDegreeBudget n A h (kernelDegreeBudget (d i) h (pathDegreeBudget n d A h e i))
noncomputable def physicalKernel {n r E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(z : Fin n β†’ β„€) (i : β„•) (s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
(B : Fin r β†’ Finset β„•) : Submodule β„‚ (totalSpace (Οƒ := Fin n) (K := β„‚) E) :=
stagedEvaluationSpace (evaluationCell G.points s.1 z (cumulativeBlockPrimes B i)) (d i) E
noncomputable def physicalNext {n E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(A h e : β„•) (z : Fin n β†’ β„€) (i : β„•)
(s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
(W : Submodule β„‚ (totalSpace (Οƒ := Fin n) (K := β„‚) E)) :
Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n :=
firstCoveringChild z s (kernelChildList G (d i) A h (pathDegreeBudget n d A h e i) s.1 W)
def PhysicalState {n : β„•} (G : KernelGeometry n) (h e : β„•) (z : Fin n β†’ β„€)
(s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n) : Prop :=
KernelParent h e s.1 ∧ s.2.On s.1 ∧ s.2.Bounded e G.height ∧ PatchPieceCovers s z
theorem physicalKernel_mono {n r E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(z : Fin n β†’ β„€) (i : β„•) (s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
{B C : Fin r β†’ Finset β„•} (hBC : βˆ€ j, B j βŠ† C j) :
physicalKernel (E := E) G d z i s B ≀ physicalKernel G d z i s C :=
stagedEvaluationSpace_mono (evaluationCell_antitone G.points s.1 z
(cumulativeBlockPrimes_mono hBC i))
theorem physical_step {n r E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(A h e : β„•) (z : Fin n β†’ β„€) (hz : z ∈ G.points) (i : β„•)
(s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
(hs : PhysicalState G h (pathDegreeBudget n d A h e i) z s)
(B : Fin r β†’ Finset β„•) :
let W := physicalKernel (E := E) G d z i s B
let t := physicalNext G d A h e z i s W
PhysicalState G h (pathDegreeBudget n d A h e (i+1)) z t ∧
t ∈ kernelChildList G (d i) A h (pathDegreeBudget n d A h e i) s.1 W ∧
s.1 ≀ t.1 ∧ stagedKernelPolynomials (d i) E W βŠ† t.1 ∧
affineDimension t.1 ≀ affineDimension s.1 ∧
(Β¬ stagedKernelPolynomials (d i) E W βŠ† s.1 β†’ affineDimension t.1 < affineDimension s.1) := by
classical
dsimp only
have hc := kernelChildList_spec G (d i) A h (pathDegreeBudget n d A h e i) s.1
(physicalKernel (E := E) G d z i s B) hs.1
have hzc : z ∈ evaluationCell G.points s.1 z (cumulativeBlockPrimes B i) := by
exact Finset.mem_filter.mpr ⟨hz,hs.2.2.2.1,by simp⟩
have hzF : βˆ€ p ∈ stagedKernelPolynomials (d i) E (physicalKernel G d z i s B),
eval (fun l => (z l : β„‚)) p = 0 := by
rintro p ⟨v,hv,rfl,_⟩
exact hv.2 z hzc
have hsel := firstCoveringChild_spec z s _ (hc.2.2 z hz hs.2.2.2.1 hzF)
have hg := hc.2.1 _ hsel.1
obtain ⟨⟨hp,hle,hdim,hdeg,hOn,hBound,_⟩,hF,hdim',hstrict⟩ := hg
exact ⟨⟨⟨hp,hdim,hdeg⟩,hOn,hBound,hsel.2⟩,hsel.1,hle,hF,hdim',hstrict⟩
theorem physical_path_good {n r E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(A h e : β„•) (z : Fin n β†’ β„€) (hz : z ∈ G.points)
(B : Fin r β†’ Finset β„•) (m i : β„•)
(s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
(hs : PhysicalState G h (pathDegreeBudget n d A h e i) z s) :
βˆ€ t ∈ adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B,
βˆƒ j, i ≀ j ∧ j ≀ i+m ∧ PhysicalState G h (pathDegreeBudget n d A h e j) z t := by
induction m generalizing i s with
| zero =>
intro t ht
have ht : t = s := by simpa only [adaptiveStates,List.mem_singleton] using ht
subst t
exact ⟨i,le_rfl,by omega,hs⟩
| succ m ih =>
intro t ht
rcases List.mem_cons.mp ht with hts | ht
Β· subst t
exact ⟨i,le_rfl,by omega,hs⟩
Β· have hstep := (physical_step (E := E) G d A h e z hz i s hs B).1
obtain ⟨j,hij,hj,htj⟩ := ih (i+1) _ hstep t ht
exact ⟨j,by omega,by omega,htj⟩
theorem physical_rank_mono_stable {n r E : β„•} (G : KernelGeometry n) (d : β„• β†’ β„•)
(A h e : β„•) (z : Fin n β†’ β„€) (m i : β„•)
(s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n)
{B C : Fin r β†’ Finset β„•} (hBC : βˆ€ j, B j βŠ† C j) :
adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C ≀
adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B ∧
(adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C =
adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B β†’
adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C =
adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B) := by
let := totalSpace_finite (n := n) (K := β„‚) E
exact adaptiveCode_mono_stable _ _ B C (fun i s => physicalKernel_mono G d z i s hBC) m i s
open MvPolynomial
open scoped BigOperators
theorem physical_uniform_minor_height (n : β„•) (d : β„• β†’ β„•) (A h e m E : β„•) :
βˆƒ C : ℝ, 1 ≀ C ∧ βˆƒ b : β„•,
βˆ€ (G : KernelGeometry n) (z : Fin n β†’ β„€), z ∈ G.points β†’
βˆ€ (s : Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n),
PhysicalState G h e z s β†’ βˆ€ (r : β„•) (B : Fin r β†’ Finset β„•),
βˆ€ t ∈ adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m 0 s B,
eval z t.2.minor β‰  0 ∧ |((eval z t.2.minor : β„€) : ℝ)| ≀ C*G.height^b := by
classical
let D := (Finset.range (m+1)).sup (pathDegreeBudget n d A h e)
obtain ⟨C,hC,b,hb⟩ := uniform_patch_minor_height n D
refine ⟨C,hC,b,?_⟩
intro G z hz s hs r B t ht
obtain ⟨j,_,hj,hjt⟩ := physical_path_good (E := E) G d A h e z hz B m 0 s hs t ht
have hD : pathDegreeBudget n d A h e j ≀ D :=
Finset.le_sup (f := pathDegreeBudget n d A h e) (Finset.mem_range.mpr (by omega))
exact ⟨hjt.2.2.2.2,hb t.2 G.height G.one_le_height (hjt.2.2.1.mono hD) z (G.bounded z hz)⟩
theorem physical_regular_blocks (n : β„•) (d : β„• β†’ β„•) (A h e m E : β„•) :
βˆƒ C : ℝ, 1 ≀ C ∧ βˆƒ b : β„•,
βˆ€ (G : KernelGeometry n)
(start : G.points β†’ Ideal (MvPolynomial (Fin n) β„‚) Γ— IntegerPatch n),
(βˆ€ z, PhysicalState G h e z.val (start z)) β†’
βˆ€ (r : β„•) (P : Fin r β†’ Finset β„•) (ell : Fin r β†’ β„•) (T : β„•)
(X ΞΆ w Ξ· ΞΎ : ℝ), 1 < X β†’ C ≀ X β†’ 0 ≀ w β†’ G.height ≀ X^w β†’ 0 < ΞΆ β†’ 0 < ΞΎ β†’
(βˆ€ i p, p ∈ P i β†’ p.Prime) β†’
(βˆ€ i p, p ∈ P i β†’ X^ΞΆ ≀ (p : ℝ)) β†’
0 < T β†’ (βˆ€ i, ell i+T < (P i).card) β†’
(βˆ€ i, ((((E+n).choose n+1)^m : β„•) : ℝ)/T +
(⌊((w*b+1)*(m+1:β„•))/ΞΆβŒ‹β‚Š : ℝ)/(((P i).card : ℝ)-(ell i+T)) ≀ Ξ·) β†’
βˆƒ B : Fin r β†’ Finset β„•,
(βˆ€ i, B i βŠ† P i ∧ ell i < (B i).card ∧ (B i).card ≀ ell i+T) ∧
((Finset.univ.filter fun z : G.points => βˆ€ i,
((βˆ‘ p ∈ B i,
if (p : β„€) ∣ ((adaptiveStates (physicalKernel (E := E) G d z.val)
(physicalNext G d A h e z.val) m 0 (start z) B).map
(fun t => eval z.val t.2.minor)).prod
then (1 : ℝ) else 0) / (B i).card) ≀ ΞΎ).card : ℝ) β‰₯
(1-(r : ℝ)*Ξ·/ΞΎ)*G.points.card := by
classical
obtain ⟨C,hC,b,hb⟩ := physical_uniform_minor_height n d A h e m E
refine ⟨C,hC,b,?_⟩
intro G start hs r P ell T X ΞΆ w Ξ· ΞΎ hX hCX hw hheight hΞΆ hΞΎ hp hsmall hT hsize hΞ·
let := totalSpace_finite (n := n) (K := β„‚) E
have hmono : βˆ€ (z : G.points) j s (B : Fin r β†’ Finset β„•) i U U', U βŠ† U' β†’
physicalKernel (E := E) G d z.val j s (Function.update B i U) ≀
physicalKernel G d z.val j s (Function.update B i U') := by
intro z j s B i U U' hUU'
apply physicalKernel_mono
intro k
by_cases hk : k = i
Β· subst k; simpa using hUU'
Β· simp only [Function.update_of_ne hk]
exact Finset.Subset.refl _
have hminor : βˆ€ (z : G.points) B, (βˆ€ i, B i βŠ† P i) β†’
βˆ€ t ∈ adaptiveStates (physicalKernel (E := E) G d z.val)
(physicalNext G d A h e z.val) m 0 (start z) B,
eval z.val t.2.minor β‰  0 ∧ |((eval z.val t.2.minor : β„€) : ℝ)| ≀ X^(w*b+1) := by
intro z B _ t ht
have ht' := hb G z.val z.property (start z) (hs z) r B t ht
refine ⟨ht'.1,ht'.2.trans ?_⟩
calc
C*G.height^b ≀ X*(X^w)^b := mul_le_mul hCX
(pow_le_pow_leftβ‚€ (zero_le_one.trans G.one_le_height) hheight b)
(pow_nonneg (zero_le_one.trans G.one_le_height) b) (zero_lt_one.trans hX).le
_ = X^(w*b+1) := by
rw [Real.rpow_add (zero_lt_one.trans hX), Real.rpow_one,
Real.rpow_mul (zero_lt_one.trans hX).le,Real.rpow_natCast,mul_comm]
have hΞ·' : βˆ€ i, (((Module.finrank β„‚ (totalSpace (Οƒ := Fin n) (K := β„‚) E)+1)^m : β„•) : ℝ)/T +
(⌊((w*b+1)*(m+1:β„•))/ΞΆβŒ‹β‚Š : ℝ)/(((P i).card : ℝ)-(ell i+T)) ≀ Ξ· := by
simpa only [totalSpace_finrank] using hΞ·
simpa only [Fintype.card_coe] using
regular_adaptive_blocks P ell T m (fun z => physicalKernel (E := E) G d z.val)
(fun z => physicalNext G d A h e z.val) start
(fun z t => eval z.val t.2.minor) hmono X ΞΆ (w*b+1) Ξ· ΞΎ hX hΞΆ hΞΎ hp hsmall hminor
hT hsize hΞ·'
end QuarticPowerFree
end OAI