From 6ab737ca26edad4afe9400f2c32fc994109d397b Mon Sep 17 00:00:00 2001 From: George Tsoukalas Date: Sat, 3 Aug 2024 15:30:21 +0000 Subject: [PATCH 1/4] Fix optParam issue. --- lean4/src/putnam_1962_a2.lean | 6 ++++-- lean4/src/putnam_1962_b6.lean | 6 ++++-- lean4/src/putnam_1963_a3.lean | 10 ++++++---- lean4/src/putnam_1963_a4.lean | 6 ++++-- lean4/src/putnam_1963_a6.lean | 6 ++++-- lean4/src/putnam_1963_b2.lean | 6 +++--- lean4/src/putnam_1963_b3.lean | 3 ++- lean4/src/putnam_1963_b6.lean | 3 ++- lean4/src/putnam_1964_a1.lean | 3 ++- lean4/src/putnam_1964_a3.lean | 4 ++-- lean4/src/putnam_1964_a5.lean | 3 ++- lean4/src/putnam_1964_a6.lean | 6 ++++-- lean4/src/putnam_1964_b1.lean | 3 ++- lean4/src/putnam_1964_b6.lean | 6 ++++-- lean4/src/putnam_1965_a1.lean | 3 ++- lean4/src/putnam_1965_a6.lean | 3 ++- lean4/src/putnam_1965_b2.lean | 5 +++-- lean4/src/putnam_1965_b5.lean | 4 ++-- lean4/src/putnam_1965_b6.lean | 6 ++++-- lean4/src/putnam_1966_a1.lean | 3 ++- lean4/src/putnam_1966_a2.lean | 9 +++++---- lean4/src/putnam_1966_a5.lean | 3 ++- lean4/src/putnam_1966_b2.lean | 5 ++--- lean4/src/putnam_1967_a1.lean | 3 ++- lean4/src/putnam_1967_a3.lean | 7 ++++--- lean4/src/putnam_1967_a6.lean | 3 ++- lean4/src/putnam_1967_b1.lean | 7 ++++--- lean4/src/putnam_1968_a5.lean | 3 ++- lean4/src/putnam_1969_a2.lean | 3 ++- lean4/src/putnam_1969_b2.lean | 3 ++- lean4/src/putnam_1969_b5.lean | 6 ++++-- lean4/src/putnam_1970_a1.lean | 3 ++- lean4/src/putnam_1970_b5.lean | 3 ++- lean4/src/putnam_1970_b6.lean | 3 ++- lean4/src/putnam_1971_a1.lean | 3 ++- lean4/src/putnam_1971_a3.lean | 3 ++- lean4/src/putnam_1971_a4.lean | 3 ++- lean4/src/putnam_1971_a5.lean | 3 ++- lean4/src/putnam_1971_b2.lean | 3 ++- lean4/src/putnam_1971_b6.lean | 3 ++- lean4/src/putnam_1972_a1.lean | 3 ++- lean4/src/putnam_1972_a3.lean | 6 ++++-- lean4/src/putnam_1972_b1.lean | 3 ++- lean4/src/putnam_1972_b2.lean | 3 ++- lean4/src/putnam_1972_b4.lean | 3 ++- lean4/src/putnam_1972_b6.lean | 3 ++- lean4/src/putnam_1973_a2.lean | 6 ++++-- lean4/src/putnam_1973_a3.lean | 3 ++- lean4/src/putnam_1973_a4.lean | 3 ++- lean4/src/putnam_1973_a6.lean | 5 +++-- lean4/src/putnam_1973_b4.lean | 3 ++- lean4/src/putnam_1974_a1.lean | 6 ++++-- lean4/src/putnam_1974_a6.lean | 4 ++-- lean4/src/putnam_1974_b1.lean | 6 ++++-- lean4/src/putnam_1974_b6.lean | 7 ++++--- lean4/src/putnam_1975_a1.lean | 5 +++-- lean4/src/putnam_1975_a3.lean | 6 ++++-- lean4/src/putnam_1975_a4.lean | 4 ++-- lean4/src/putnam_1975_b1.lean | 3 ++- lean4/src/putnam_1975_b2.lean | 3 ++- lean4/src/putnam_1975_b4.lean | 3 ++- lean4/src/putnam_1975_b5.lean | 3 ++- lean4/src/putnam_1975_b6.lean | 3 ++- lean4/src/putnam_1976_a2.lean | 13 ++++++++----- lean4/src/putnam_1976_a4.lean | 7 +++---- lean4/src/putnam_1976_b2.lean | 6 ++++-- lean4/src/putnam_1976_b6.lean | 6 ++++-- lean4/src/putnam_1977_a1.lean | 3 ++- lean4/src/putnam_1977_a6.lean | 6 ++++-- lean4/src/putnam_1977_b3.lean | 8 +++++--- lean4/src/putnam_1977_b6.lean | 6 ++++-- lean4/src/putnam_1978_a1.lean | 4 ++-- lean4/src/putnam_1978_a2.lean | 6 ++++-- lean4/src/putnam_1978_a3.lean | 6 ++++-- lean4/src/putnam_1978_a4.lean | 3 ++- lean4/src/putnam_1978_a5.lean | 3 ++- lean4/src/putnam_1978_a6.lean | 3 ++- lean4/src/putnam_1978_b5.lean | 3 ++- lean4/src/putnam_1979_a1.lean | 3 ++- lean4/src/putnam_1979_a4.lean | 6 ++++-- lean4/src/putnam_1979_a5.lean | 6 ++++-- lean4/src/putnam_1979_b3.lean | 7 ++++--- lean4/src/putnam_1980_b5.lean | 9 ++++++--- lean4/src/putnam_1981_a1.lean | 3 ++- lean4/src/putnam_1981_a3.lean | 3 ++- lean4/src/putnam_1981_a5.lean | 6 ++++-- lean4/src/putnam_1981_b1.lean | 3 ++- lean4/src/putnam_1981_b2.lean | 6 ++++-- lean4/src/putnam_1981_b3.lean | 3 ++- lean4/src/putnam_1982_a2.lean | 6 ++++-- lean4/src/putnam_1982_a4.lean | 5 +++-- lean4/src/putnam_1982_a5.lean | 2 -- lean4/src/putnam_1982_a6.lean | 12 ++++++++---- lean4/src/putnam_1982_b2.lean | 8 +++++--- lean4/src/putnam_1982_b3.lean | 3 ++- lean4/src/putnam_1982_b4.lean | 3 ++- lean4/src/putnam_1982_b5.lean | 3 ++- lean4/src/putnam_1983_a4.lean | 7 ++++--- lean4/src/putnam_1983_a6.lean | 3 ++- lean4/src/putnam_1983_b2.lean | 3 ++- lean4/src/putnam_1983_b4.lean | 5 +++-- lean4/src/putnam_1983_b5.lean | 5 +++-- lean4/src/putnam_1984_a6.lean | 6 ++++-- lean4/src/putnam_1985_a5.lean | 3 ++- lean4/src/putnam_1985_a6.lean | 6 ++++-- lean4/src/putnam_1985_b1.lean | 6 ++++-- lean4/src/putnam_1986_a1.lean | 6 ++++-- lean4/src/putnam_1986_a3.lean | 3 ++- lean4/src/putnam_1986_a4.lean | 3 ++- lean4/src/putnam_1986_a5.lean | 9 ++++++--- lean4/src/putnam_1986_b3.lean | 3 ++- lean4/src/putnam_1986_b5.lean | 6 ++++-- lean4/src/putnam_1987_a4.lean | 3 ++- lean4/src/putnam_1987_a5.lean | 19 ++++++++++++------- lean4/src/putnam_1987_a6.lean | 3 ++- lean4/src/putnam_1987_b6.lean | 5 +++-- lean4/src/putnam_1988_a1.lean | 3 ++- lean4/src/putnam_1988_a2.lean | 3 ++- lean4/src/putnam_1988_a4.lean | 3 ++- lean4/src/putnam_1989_b1.lean | 12 ++++++++---- lean4/src/putnam_1989_b6.lean | 12 ++++++++---- lean4/src/putnam_1992_a2.lean | 3 ++- lean4/src/putnam_1992_a5.lean | 3 ++- lean4/src/putnam_1992_b1.lean | 3 ++- lean4/src/putnam_1992_b2.lean | 3 ++- lean4/src/putnam_1992_b4.lean | 6 ++++-- lean4/src/putnam_1992_b5.lean | 3 ++- lean4/src/putnam_1993_b3.lean | 3 ++- lean4/src/putnam_1994_a3.lean | 3 ++- lean4/src/putnam_1995_a2.lean | 3 ++- lean4/src/putnam_1995_a3.lean | 3 ++- lean4/src/putnam_1995_a5.lean | 12 ++++++++---- lean4/src/putnam_1995_a6.lean | 9 ++++++--- lean4/src/putnam_1995_b3.lean | 6 ++++-- lean4/src/putnam_1995_b6.lean | 3 ++- lean4/src/putnam_1996_a2.lean | 5 +++-- lean4/src/putnam_1996_a5.lean | 3 ++- lean4/src/putnam_1997_a3.lean | 5 +++-- lean4/src/putnam_1997_a5.lean | 3 ++- lean4/src/putnam_1997_a6.lean | 3 ++- lean4/src/putnam_1997_b1.lean | 3 ++- lean4/src/putnam_1998_a2.lean | 14 +++++++++----- lean4/src/putnam_1998_b4.lean | 5 +++-- lean4/src/putnam_1998_b5.lean | 3 ++- lean4/src/putnam_1999_a3.lean | 3 ++- lean4/src/putnam_1999_b3.lean | 6 ++++-- lean4/src/putnam_1999_b5.lean | 6 ++++-- lean4/src/putnam_2000_b3.lean | 6 ++++-- lean4/src/putnam_2001_a3.lean | 3 ++- lean4/src/putnam_2002_a2.lean | 8 +++++--- lean4/src/putnam_2002_b3.lean | 6 ++++-- lean4/src/putnam_2002_b6.lean | 6 ++++-- lean4/src/putnam_2003_a5.lean | 6 ++++-- lean4/src/putnam_2004_a5.lean | 9 ++++++--- lean4/src/putnam_2004_b4.lean | 4 ++-- lean4/src/putnam_2005_a2.lean | 9 ++++++--- lean4/src/putnam_2006_b1.lean | 6 ++++-- lean4/src/putnam_2006_b4.lean | 7 +++---- lean4/src/putnam_2006_b5.lean | 6 ++++-- lean4/src/putnam_2007_a3.lean | 6 ++++-- lean4/src/putnam_2007_a4.lean | 3 ++- lean4/src/putnam_2007_b6.lean | 3 ++- lean4/src/putnam_2008_a3.lean | 9 ++++++--- lean4/src/putnam_2008_b3.lean | 6 ++++-- lean4/src/putnam_2008_b5.lean | 6 +++--- lean4/src/putnam_2009_b1.lean | 8 ++++---- lean4/src/putnam_2009_b3.lean | 6 ++++-- lean4/src/putnam_2009_b4.lean | 3 ++- lean4/src/putnam_2010_b3.lean | 3 ++- lean4/src/putnam_2011_a1.lean | 3 ++- lean4/src/putnam_2011_a5.lean | 3 ++- lean4/src/putnam_2011_a6.lean | 3 ++- lean4/src/putnam_2011_b4.lean | 6 ++++-- lean4/src/putnam_2012_a3.lean | 8 +++++--- lean4/src/putnam_2012_a6.lean | 3 ++- lean4/src/putnam_2012_b1.lean | 19 ++++++++++--------- lean4/src/putnam_2012_b3.lean | 10 ++++++---- lean4/src/putnam_2013_a2.lean | 9 ++++++--- lean4/src/putnam_2013_b2.lean | 6 ++++-- lean4/src/putnam_2014_a4.lean | 6 ++++-- lean4/src/putnam_2014_b1.lean | 3 ++- lean4/src/putnam_2014_b2.lean | 8 +++++--- lean4/src/putnam_2015_a1.lean | 3 ++- lean4/src/putnam_2015_a4.lean | 9 ++++++--- lean4/src/putnam_2015_b5.lean | 3 ++- lean4/src/putnam_2016_a2.lean | 3 ++- lean4/src/putnam_2016_a5.lean | 3 ++- lean4/src/putnam_2016_a6.lean | 3 ++- lean4/src/putnam_2016_b2.lean | 9 ++++++--- lean4/src/putnam_2016_b4.lean | 5 +++-- lean4/src/putnam_2017_b1.lean | 3 ++- lean4/src/putnam_2017_b2.lean | 9 ++++++--- lean4/src/putnam_2018_a3.lean | 3 ++- lean4/src/putnam_2018_a6.lean | 3 ++- lean4/src/putnam_2018_b5.lean | 12 +++++++----- lean4/src/putnam_2019_a3.lean | 6 ++++-- lean4/src/putnam_2019_b2.lean | 3 ++- lean4/src/putnam_2019_b3.lean | 3 ++- lean4/src/putnam_2020_a5.lean | 3 ++- lean4/src/putnam_2020_a6.lean | 3 ++- lean4/src/putnam_2020_b1.lean | 6 ++++-- lean4/src/putnam_2020_b4.lean | 9 ++++++--- lean4/src/putnam_2021_a1.lean | 3 ++- lean4/src/putnam_2021_a3.lean | 9 ++++++--- lean4/src/putnam_2021_a4.lean | 8 +++++--- lean4/src/putnam_2021_b3.lean | 6 ++++-- lean4/src/putnam_2021_b5.lean | 3 ++- lean4/src/putnam_2022_a2.lean | 6 ++++-- lean4/src/putnam_2022_a3.lean | 4 ++-- lean4/src/putnam_2022_b3.lean | 3 ++- lean4/src/putnam_2023_a2.lean | 3 ++- lean4/src/putnam_2023_b1.lean | 9 ++++++--- 212 files changed, 688 insertions(+), 390 deletions(-) diff --git a/lean4/src/putnam_1962_a2.lean b/lean4/src/putnam_1962_a2.lean index 3eb3a425..057467c3 100644 --- a/lean4/src/putnam_1962_a2.lean +++ b/lean4/src/putnam_1962_a2.lean @@ -6,8 +6,10 @@ open MeasureTheory abbrev putnam_1962_a2_solution : Set (ℝ → ℝ) := sorry -- {f : ℝ → ℝ | ∃ a c : ℝ, a > 0 ∧ f = fun x => a / (1 - c * x)^2} theorem putnam_1962_a2 -(hf : ℝ → (ℝ → ℝ) → Prop := fun (e : ℝ) (f : ℝ → ℝ) => ∀ x ∈ Set.Ioo 0 e, (⨍ v in Set.Icc 0 x, f v) = Real.sqrt ((f 0) * (f x))) -(hfinf : (ℝ → ℝ) → Prop := fun (f : ℝ → ℝ) => ∀ x > 0, (⨍ v in Set.Icc 0 x, f v) = Real.sqrt ((f 0) * (f x))) +(hf : ℝ → (ℝ → ℝ) → Prop) +(hf_def : hf = fun (e : ℝ) (f : ℝ → ℝ) => ∀ x ∈ Set.Ioo 0 e, (⨍ v in Set.Icc 0 x, f v) = Real.sqrt ((f 0) * (f x))) +(hfinf : (ℝ → ℝ) → Prop) +(hfinf_def : hfinf = fun (f : ℝ → ℝ) => ∀ x > 0, (⨍ v in Set.Icc 0 x, f v) = Real.sqrt ((f 0) * (f x))) : (∀ f : ℝ → ℝ, (hfinf f → ∃ g ∈ putnam_1962_a2_solution, ∀ x ≥ 0, g x = f x) ∧ ∀ e > 0, hf e f → ∃ g ∈ putnam_1962_a2_solution, ∀ x ∈ Set.Ico 0 e, g x = f x) ∧ ∀ f ∈ putnam_1962_a2_solution, hfinf f ∨ (∃ e > 0, hf e f) := diff --git a/lean4/src/putnam_1962_b6.lean b/lean4/src/putnam_1962_b6.lean index 7205e648..808f4d76 100644 --- a/lean4/src/putnam_1962_b6.lean +++ b/lean4/src/putnam_1962_b6.lean @@ -4,11 +4,13 @@ open BigOperators open MeasureTheory theorem putnam_1962_b6 -(π : ℝ := Real.pi) +(π : ℝ) +(hπ : π = Real.pi) (n : ℕ) (a b : ℕ → ℝ) (xs : Set ℝ) -(f : ℝ → ℝ := fun x : ℝ => ∑ k in Finset.Icc 0 n, ((a k) * Real.sin (k * x) + (b k) * Real.cos (k * x))) +(f : ℝ → ℝ) +(hf : f = fun x : ℝ => ∑ k in Finset.Icc 0 n, ((a k) * Real.sin (k * x) + (b k) * Real.cos (k * x))) (hf1 : ∀ x ∈ Set.Icc 0 (2 * π), |f x| ≤ 1) (hxs : xs.ncard = 2 * n ∧ xs ⊆ Set.Ico 0 (2 * π)) (hfxs : ∀ x ∈ xs, |f x| = 1) diff --git a/lean4/src/putnam_1963_a3.lean b/lean4/src/putnam_1963_a3.lean index 9b50e86c..43fab6e6 100644 --- a/lean4/src/putnam_1963_a3.lean +++ b/lean4/src/putnam_1963_a3.lean @@ -8,10 +8,12 @@ noncomputable abbrev putnam_1963_a3_solution : (ℝ → ℝ) → ℕ → ℝ → theorem putnam_1963_a3 (n : ℕ) (f : ℝ → ℝ) -(P : ℕ → (ℝ → ℝ) → (ℝ → ℝ)) -(δ : (ℝ → ℝ) → (ℝ → ℝ) := fun g : ℝ → ℝ ↦ (fun x : ℝ ↦ x) * deriv g) -(D : ℕ → (ℝ → ℝ) → (ℝ → ℝ) := fun (m : ℕ) (g : ℝ → ℝ) ↦ δ g - (fun x : ℝ ↦ (m : ℝ)) * g) -(y : ℝ → ℝ := fun x : ℝ ↦ ∫ t in Set.Ioo 1 x, putnam_1963_a3_solution f n x t) +(P D : ℕ → (ℝ → ℝ) → (ℝ → ℝ)) +(δ : (ℝ → ℝ) → (ℝ → ℝ)) +(hδ : δ = fun g : ℝ → ℝ ↦ (fun x : ℝ ↦ x) * deriv g) +(hD : D = fun (m : ℕ) (g : ℝ → ℝ) ↦ δ g - (fun x : ℝ ↦ (m : ℝ)) * g) +(y : ℝ → ℝ) +(hy : y = fun x : ℝ ↦ ∫ t in Set.Ioo 1 x, putnam_1963_a3_solution f n x t) (hn : n ≥ 1) (hf : Continuous f) (hP : P 0 y = y ∧ ∀ m ∈ Finset.range n, P (m + 1) y = D (n - 1 - m) (P m y)) diff --git a/lean4/src/putnam_1963_a4.lean b/lean4/src/putnam_1963_a4.lean index ece0b33f..a5e2706e 100644 --- a/lean4/src/putnam_1963_a4.lean +++ b/lean4/src/putnam_1963_a4.lean @@ -4,7 +4,9 @@ open BigOperators open Topology Filter theorem putnam_1963_a4 -(apos : (ℕ → ℝ) → Prop := fun a => ∀ n, a n > 0) -(f : (ℕ → ℝ) → ℕ → ℝ := fun a n => n * (((1 + a (n+1)) / (a n)) - 1)) +(apos : (ℕ → ℝ) → Prop) +(hapos : apos = fun a => ∀ n, a n > 0) +(f : (ℕ → ℝ) → ℕ → ℝ) +(hf : f = fun (a : ℕ → ℝ) n => n * (((1 + a (n+1)) / (a n)) - 1)) : (∀ a, apos a → limsup (f a) atTop ≥ 1) ∧ (¬∃ c > 1, ∀ a, apos a → limsup (f a) atTop ≥ c) := sorry diff --git a/lean4/src/putnam_1963_a6.lean b/lean4/src/putnam_1963_a6.lean index 473f0ef7..b0c5174f 100644 --- a/lean4/src/putnam_1963_a6.lean +++ b/lean4/src/putnam_1963_a6.lean @@ -6,8 +6,10 @@ open Topology Filter theorem putnam_1963_a6 (F1 F2 U V A B C D P Q : EuclideanSpace ℝ (Fin 2)) (r : ℝ) -(E : Set (Fin 2 → ℝ) := {H : EuclideanSpace ℝ (Fin 2) | dist F1 H + dist F2 H = r}) -(M : EuclideanSpace ℝ (Fin 2) := midpoint ℝ U V) +(E : Set (EuclideanSpace ℝ (Fin 2))) +(hE : E = {H : EuclideanSpace ℝ (Fin 2) | dist F1 H + dist F2 H = r}) +(M : EuclideanSpace ℝ (Fin 2)) +(hM : M = midpoint ℝ U V) (hr : r > dist F1 F2) (hUV : U ∈ E ∧ V ∈ E ∧ U ≠ V) (hAB : A ∈ E ∧ B ∈ E ∧ A ≠ B) diff --git a/lean4/src/putnam_1963_b2.lean b/lean4/src/putnam_1963_b2.lean index 654184c8..501f9b10 100644 --- a/lean4/src/putnam_1963_b2.lean +++ b/lean4/src/putnam_1963_b2.lean @@ -6,7 +6,7 @@ open Topology Filter Polynomial abbrev putnam_1963_b2_solution : Prop := sorry -- True theorem putnam_1963_b2 -(S : Set ℝ := {2 ^ m * 3 ^ n | (m : ℤ) (n : ℤ)}) -(P : Set ℝ := Set.Ioi 0) -: closure S ⊇ P ↔ putnam_1963_b2_solution := +(S : Set ℝ) +(hS : S = {2 ^ m * 3 ^ n | (m : ℤ) (n : ℤ)}) +: closure S ⊇ Set.Ioi (0 : ℝ) ↔ putnam_1963_b2_solution := sorry diff --git a/lean4/src/putnam_1963_b3.lean b/lean4/src/putnam_1963_b3.lean index 934a3d52..bc8988fa 100644 --- a/lean4/src/putnam_1963_b3.lean +++ b/lean4/src/putnam_1963_b3.lean @@ -7,6 +7,7 @@ abbrev putnam_1963_b3_solution : Set (ℝ → ℝ) := sorry -- {(fun u : ℝ => A * Real.sinh (k * u)) | (A : ℝ) (k : ℝ)} ∪ {(fun u : ℝ => A * u) | A : ℝ} ∪ {(fun u : ℝ => A * Real.sin (k * u)) | (A : ℝ) (k : ℝ)} theorem putnam_1963_b3 (f : ℝ → ℝ) -(fdiff : Prop := ContDiff ℝ 1 f ∧ Differentiable ℝ (deriv f)) +(fdiff : Prop) +(hfdiff : fdiff ↔ ContDiff ℝ 1 f ∧ Differentiable ℝ (deriv f)) : (fdiff ∧ ∀ x y : ℝ, (f x) ^ 2 - (f y) ^ 2 = f (x + y) * f (x - y)) ↔ f ∈ putnam_1963_b3_solution := sorry diff --git a/lean4/src/putnam_1963_b6.lean b/lean4/src/putnam_1963_b6.lean index 4565e1f8..07044952 100644 --- a/lean4/src/putnam_1963_b6.lean +++ b/lean4/src/putnam_1963_b6.lean @@ -5,7 +5,8 @@ open Topology Filter Polynomial theorem putnam_1963_b6 (d : ℕ) -(S : Set (Fin d → ℝ) → Set (Fin d → ℝ) := (fun A : Set (Fin d → ℝ) => ⋃ p ∈ A, ⋃ q ∈ A, segment ℝ p q)) +(S : Set (Fin d → ℝ) → Set (Fin d → ℝ)) +(hS : S = (fun A : Set (Fin d → ℝ) => ⋃ p ∈ A, ⋃ q ∈ A, segment ℝ p q)) (A : ℕ → Set (Fin d → ℝ)) (ddim : 1 ≤ d ∧ d ≤ 3) (hA0 : Nonempty (A 0)) diff --git a/lean4/src/putnam_1964_a1.lean b/lean4/src/putnam_1964_a1.lean index 18098521..32f23bd1 100644 --- a/lean4/src/putnam_1964_a1.lean +++ b/lean4/src/putnam_1964_a1.lean @@ -4,6 +4,7 @@ open BigOperators theorem putnam_1964_a1 (A : Finset (EuclideanSpace ℝ (Fin 2))) (hAcard : A.card = 6) -(dists : Set ℝ := {d : ℝ | ∃ a b : EuclideanSpace ℝ (Fin 2), a ∈ A ∧ b ∈ A ∧ a ≠ b ∧ d = dist a b}) +(dists : Set ℝ) +(hdists : dists = {d : ℝ | ∃ a b : EuclideanSpace ℝ (Fin 2), a ∈ A ∧ b ∈ A ∧ a ≠ b ∧ d = dist a b}) : (sSup dists / sInf dists ≥ Real.sqrt 3) := sorry diff --git a/lean4/src/putnam_1964_a3.lean b/lean4/src/putnam_1964_a3.lean index 20ed309c..7f4b531e 100644 --- a/lean4/src/putnam_1964_a3.lean +++ b/lean4/src/putnam_1964_a3.lean @@ -7,7 +7,7 @@ theorem putnam_1964_a3 (x a b : ℕ → ℝ) (hxdense : range x ⊆ Ioo 0 1 ∧ closure (range x) ⊇ Ioo 0 1) (hxinj : Injective x) -(a := fun n ↦ x n - sSup ({0} ∪ {p : ℝ | p < x n ∧ ∃ i < n, p = x i})) -(b := fun n ↦ sInf ({1} ∪ {p : ℝ | p > x n ∧ ∃ i < n, p = x i}) - x n) +(ha : a = fun n ↦ x n - sSup ({0} ∪ {p : ℝ | p < x n ∧ ∃ i < n, p = x i})) +(hb : b = fun n ↦ sInf ({1} ∪ {p : ℝ | p > x n ∧ ∃ i < n, p = x i}) - x n) : (∑' n : ℕ, a n * b n * (a n + b n) = 1 / 3) := sorry diff --git a/lean4/src/putnam_1964_a5.lean b/lean4/src/putnam_1964_a5.lean index 176876d0..816e862d 100644 --- a/lean4/src/putnam_1964_a5.lean +++ b/lean4/src/putnam_1964_a5.lean @@ -4,6 +4,7 @@ open BigOperators open Set Function Filter Topology theorem putnam_1964_a5 -(pa : (ℕ → ℝ) → Prop := fun a ↦ (∀ n : ℕ, a n > 0) ∧ ∃ L : ℝ, Tendsto (fun N ↦ ∑ n in Finset.range N, 1 / a n) atTop (𝓝 L)) +(pa : (ℕ → ℝ) → Prop) +(hpa : pa = fun a ↦ (∀ n : ℕ, a n > 0) ∧ ∃ L : ℝ, Tendsto (fun N ↦ ∑ n in Finset.range N, 1 / a n) atTop (𝓝 L)) : (∃ k : ℝ, ∀ a : ℕ → ℝ, pa a → ∑' n : ℕ, (n + 1) / (∑ i in Finset.range (n + 1), a i) ≤ k * ∑' n : ℕ, 1 / a n) := sorry diff --git a/lean4/src/putnam_1964_a6.lean b/lean4/src/putnam_1964_a6.lean index 782ae0ac..f2020df7 100644 --- a/lean4/src/putnam_1964_a6.lean +++ b/lean4/src/putnam_1964_a6.lean @@ -5,8 +5,10 @@ open Set Function Filter Topology theorem putnam_1964_a6 (S : Finset ℝ) -(pairs : Set (ℝ × ℝ) := {(a, b) | (a ∈ S) ∧ (b ∈ S) ∧ (a < b)}) -(distance : ℝ × ℝ → ℝ := fun (a, b) ↦ b - a) +(pairs : Set (ℝ × ℝ)) +(hpairs : pairs = {(a, b) | (a ∈ S) ∧ (b ∈ S) ∧ (a < b)}) +(distance : ℝ × ℝ → ℝ) +(hdistance : distance = fun (a, b) ↦ b - a) (hrepdist : ∀ p ∈ pairs, (∃ m ∈ pairs, distance m > distance p) → ∃ q ∈ pairs, q ≠ p ∧ distance p = distance q) : (∀ p q : pairs, q ≠ p → ∃ r : ℚ, distance p / distance q = r) := sorry diff --git a/lean4/src/putnam_1964_b1.lean b/lean4/src/putnam_1964_b1.lean index 90befcbb..a66ca289 100644 --- a/lean4/src/putnam_1964_b1.lean +++ b/lean4/src/putnam_1964_b1.lean @@ -7,6 +7,7 @@ theorem putnam_1964_b1 (a : ℕ → ℤ) (apos : a > 0) (ha : ∃ L : ℝ, Tendsto (fun N ↦ ∑ n in Finset.range N, (1 : ℝ) / a n) atTop (𝓝 L)) -(b : ℕ → ENNReal := fun n ↦ {k : ℕ | a k ≤ n}.encard) +(b : ℕ → ENNReal) +(hb : b = fun (n : ℕ) ↦ ({k : ℕ | a k ≤ n}.encard : ENNReal)) : (Tendsto (fun n : ℕ ↦ b n / n) atTop (𝓝 0)) := sorry diff --git a/lean4/src/putnam_1964_b6.lean b/lean4/src/putnam_1964_b6.lean index b57e9928..34e8b533 100644 --- a/lean4/src/putnam_1964_b6.lean +++ b/lean4/src/putnam_1964_b6.lean @@ -4,7 +4,9 @@ open BigOperators open Set Function Filter Topology theorem putnam_1964_b6 -(D : Set (EuclideanSpace ℝ (Fin 2)) := {v : EuclideanSpace ℝ (Fin 2) | dist 0 v ≤ 1}) -(cong : Set (EuclideanSpace ℝ (Fin 2)) → Set (EuclideanSpace ℝ (Fin 2)) → Prop := fun A B ↦ ∃ f : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)), B = f '' A ∧ ∀ v w : EuclideanSpace ℝ (Fin 2), dist v w = dist (f v) (f w)) +(D : Set (EuclideanSpace ℝ (Fin 2))) +(hD : D = {v : EuclideanSpace ℝ (Fin 2) | dist 0 v ≤ 1}) +(cong : Set (EuclideanSpace ℝ (Fin 2)) → Set (EuclideanSpace ℝ (Fin 2)) → Prop) +(hcong : cong = fun A B ↦ ∃ f : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)), B = f '' A ∧ ∀ v w : EuclideanSpace ℝ (Fin 2), dist v w = dist (f v) (f w)) : (¬∃ A B : Set (Fin 2 → ℝ), cong A B ∧ A ∩ B = ∅ ∧ A ∪ B = D) := sorry diff --git a/lean4/src/putnam_1965_a1.lean b/lean4/src/putnam_1965_a1.lean index a02595e3..3722ff96 100644 --- a/lean4/src/putnam_1965_a1.lean +++ b/lean4/src/putnam_1965_a1.lean @@ -6,7 +6,8 @@ open EuclideanGeometry noncomputable abbrev putnam_1965_a1_solution : ℝ := sorry -- Real.pi / 15 theorem putnam_1965_a1 -(π : ℝ := Real.pi) +(π : ℝ) +(hπ : π = Real.pi) (A B C X Y : EuclideanSpace ℝ (Fin 2)) (hABC : ¬Collinear ℝ {A, B, C}) (hangles : ∠ C A B < ∠ B C A ∧ ∠ B C A < π/2 ∧ π/2 < ∠ A B C) diff --git a/lean4/src/putnam_1965_a6.lean b/lean4/src/putnam_1965_a6.lean index d0064a67..3acd85cc 100644 --- a/lean4/src/putnam_1965_a6.lean +++ b/lean4/src/putnam_1965_a6.lean @@ -5,7 +5,8 @@ open EuclideanGeometry Topology Filter Complex theorem putnam_1965_a6 (u v m : ℝ) -(pinter : ℝ × ℝ → Prop := (fun p : ℝ × ℝ => u*p.1 + v*p.2 = 1 ∧ (p.1)^m + (p.2)^m = 1)) +(pinter : ℝ × ℝ → Prop) +(hpinter : pinter = (fun p : ℝ × ℝ => u*p.1 + v*p.2 = 1 ∧ (p.1)^m + (p.2)^m = 1)) (hm : m > 1) (huv : u ≥ 0 ∧ v ≥ 0) : ((∃! p : ℝ × ℝ, pinter p) ∧ (∃ p : ℝ × ℝ, p.1 ≥ 0 ∧ p.2 ≥ 0 ∧ pinter p)) ↔ (∃ n : ℝ, u^n + v^n = 1 ∧ m^(-(1 : ℤ)) + n^(-(1 : ℤ)) = 1) := diff --git a/lean4/src/putnam_1965_b2.lean b/lean4/src/putnam_1965_b2.lean index 92df958a..4224f706 100644 --- a/lean4/src/putnam_1965_b2.lean +++ b/lean4/src/putnam_1965_b2.lean @@ -9,7 +9,8 @@ theorem putnam_1965_b2 (won : Fin n → Fin n → Bool) (hirrefl : ∀ i : Fin n, won i i = False) (hantisymm : ∀ i j : Fin n, i ≠ j → won i j = ¬won j i) -(w : Fin n → ℤ := fun r : Fin n => ∑ j : Fin n, (if won r j then 1 else 0)) -(l : Fin n → ℤ := fun r : Fin n => n - 1 - w r) +(w l : Fin n → ℤ) +(hw : w = fun r : Fin n => ∑ j : Fin n, (if won r j then 1 else 0)) +(hl : l = fun r : Fin n => n - 1 - w r) : ∑ r : Fin n, (w r)^2 = ∑ r : Fin n, (l r)^2 := sorry diff --git a/lean4/src/putnam_1965_b5.lean b/lean4/src/putnam_1965_b5.lean index 4803f375..1be6653f 100644 --- a/lean4/src/putnam_1965_b5.lean +++ b/lean4/src/putnam_1965_b5.lean @@ -5,8 +5,8 @@ open EuclideanGeometry Topology Filter Complex SimpleGraph.Walk theorem putnam_1965_b5 [Fintype K] -(V : ℕ := Nat.card K) -(E : ℕ) +(V E : ℕ) +(hV : V = Nat.card K) (hE: 4*E ≤ V^2) : ∃ G : SimpleGraph K, G.edgeSet.ncard = E ∧ ∀ a : K, ∀ w : G.Walk a a, w.length ≠ 3 := sorry diff --git a/lean4/src/putnam_1965_b6.lean b/lean4/src/putnam_1965_b6.lean index c3a6e955..3e84def9 100644 --- a/lean4/src/putnam_1965_b6.lean +++ b/lean4/src/putnam_1965_b6.lean @@ -5,9 +5,11 @@ open EuclideanGeometry Topology Filter Complex SimpleGraph.Walk theorem putnam_1965_b6 (A B C D : EuclideanSpace ℝ (Fin 2)) -(S : Set (EuclideanSpace ℝ (Fin 2)) := {A, B, C, D}) +(S : Set (EuclideanSpace ℝ (Fin 2))) +(hS : S = {A, B, C, D}) (hdistinct : S.ncard = 4) -(through : (ℝ × (EuclideanSpace ℝ (Fin 2))) → (EuclideanSpace ℝ (Fin 2)) → Prop := fun (r, P) => fun Q => dist P Q = r) +(through : (ℝ × (EuclideanSpace ℝ (Fin 2))) → (EuclideanSpace ℝ (Fin 2)) → Prop) +(through_def : through = fun (r, P) => fun Q => dist P Q = r) (hABCD : ∀ r s : ℝ, ∀ P Q : EuclideanSpace ℝ (Fin 2), through (r, P) A ∧ through (r, P) B ∧ through (s, Q) C ∧ through (s, Q) D → ∃ I : EuclideanSpace ℝ (Fin 2), through (r, P) I ∧ through (s, Q) I) : Collinear ℝ S ∨ ∃ r : ℝ, ∃ P : EuclideanSpace ℝ (Fin 2), ∀ Q ∈ S, through (r, P) Q := diff --git a/lean4/src/putnam_1966_a1.lean b/lean4/src/putnam_1966_a1.lean index 1390c74a..226bd685 100644 --- a/lean4/src/putnam_1966_a1.lean +++ b/lean4/src/putnam_1966_a1.lean @@ -2,6 +2,7 @@ import Mathlib open BigOperators theorem putnam_1966_a1 -(f : ℤ → ℤ := fun n : ℤ => ∑ m in Finset.Icc 0 n, (if Even m then m / 2 else (m - 1)/2)) +(f : ℤ → ℤ) +(hf : f = fun n : ℤ => ∑ m in Finset.Icc 0 n, (if Even m then m / 2 else (m - 1)/2)) : ∀ x y : ℤ, x > 0 ∧ y > 0 ∧ x > y → x * y = f (x + y) - f (x - y) := sorry diff --git a/lean4/src/putnam_1966_a2.lean b/lean4/src/putnam_1966_a2.lean index 591a9249..972bafb3 100644 --- a/lean4/src/putnam_1966_a2.lean +++ b/lean4/src/putnam_1966_a2.lean @@ -5,10 +5,11 @@ theorem putnam_1966_a2 (r : ℝ) (A B C : EuclideanSpace ℝ (Fin 2)) (hABC : ¬Collinear ℝ {A, B, C}) -(a : ℝ := dist B C) -(b : ℝ := dist C A) -(c : ℝ := dist A B) -(p : ℝ := (dist B C + dist C A + dist A B)/2) +(a b c p : ℝ) +(ha : a = dist B C) +(hb : b = dist C A) +(hc : c = dist A B) +(hp : p = (dist B C + dist C A + dist A B)/2) (hr : ∃ I : EuclideanSpace ℝ (Fin 2), (∃! P : EuclideanSpace ℝ (Fin 2), dist I P = r ∧ Collinear ℝ {P, B, C}) ∧ (∃! Q : EuclideanSpace ℝ (Fin 2), dist I Q = r ∧ Collinear ℝ {Q, C, A}) ∧ diff --git a/lean4/src/putnam_1966_a5.lean b/lean4/src/putnam_1966_a5.lean index fccf9439..60bfb882 100644 --- a/lean4/src/putnam_1966_a5.lean +++ b/lean4/src/putnam_1966_a5.lean @@ -4,7 +4,8 @@ open BigOperators open Topology Filter theorem putnam_1966_a5 -(C : Set (ℝ → ℝ) := {f : ℝ → ℝ | Continuous f}) +(C : Set (ℝ → ℝ)) +(hC : C = {f : ℝ → ℝ | Continuous f}) (T : (ℝ → ℝ) → (ℝ → ℝ)) (imageTC : ∀ f ∈ C, T f ∈ C) (linearT : ∀ a b : ℝ, ∀ f ∈ C, ∀ g ∈ C, T ((fun x => a)*f + (fun x => b)*g) = (fun x => a)*(T f) + (fun x => b)*(T g)) diff --git a/lean4/src/putnam_1966_b2.lean b/lean4/src/putnam_1966_b2.lean index 7cd43890..55ab3e1c 100644 --- a/lean4/src/putnam_1966_b2.lean +++ b/lean4/src/putnam_1966_b2.lean @@ -1,9 +1,8 @@ import Mathlib open BigOperators -open Topology Filter - theorem putnam_1966_b2 -(S : ℤ → Set ℤ := fun n : ℤ => {n, n + 1, n + 2, n + 3, n + 4, n + 5, n + 6, n + 7, n + 8, n + 9}) +(S : ℤ → Set ℤ) +(hS : S = fun n : ℤ => {n, n + 1, n + 2, n + 3, n + 4, n + 5, n + 6, n + 7, n + 8, n + 9}) : ∀ n : ℤ, n > 0 → (∃ k ∈ S n, ∀ m ∈ S n, k ≠ m → IsCoprime m k) := sorry diff --git a/lean4/src/putnam_1967_a1.lean b/lean4/src/putnam_1967_a1.lean index 02648bf2..57141325 100644 --- a/lean4/src/putnam_1967_a1.lean +++ b/lean4/src/putnam_1967_a1.lean @@ -6,7 +6,8 @@ open Nat Topology Filter theorem putnam_1967_a1 (n : ℕ) (a : Set.Icc 1 n → ℝ) -(f : ℝ → ℝ := (fun x : ℝ => ∑ i : Set.Icc 1 n, a i * Real.sin (i * x))) +(f : ℝ → ℝ) +(hf : f = (fun x : ℝ => ∑ i : Set.Icc 1 n, a i * Real.sin (i * x))) (npos : n > 0) (flesin : ∀ x : ℝ, abs (f x) ≤ abs (Real.sin x)) : abs (∑ i : Set.Icc 1 n, i * a i) ≤ 1 := diff --git a/lean4/src/putnam_1967_a3.lean b/lean4/src/putnam_1967_a3.lean index 346130fc..62670d55 100644 --- a/lean4/src/putnam_1967_a3.lean +++ b/lean4/src/putnam_1967_a3.lean @@ -6,8 +6,9 @@ open Nat Topology Filter abbrev putnam_1967_a3_solution : ℕ := sorry -- 5 theorem putnam_1967_a3 -(pform : Polynomial ℝ → Prop := (fun p : Polynomial ℝ => p.degree = 2 ∧ ∀ i ∈ Finset.range 3, p.coeff i = round (p.coeff i))) -(pzeros : Polynomial ℝ → Prop := (fun p : Polynomial ℝ => ∃ z1 z2 : Set.Ioo (0 : ℝ) 1, z1 ≠ z2 ∧ p.eval z1.1 = 0 ∧ p.eval z2.1 = 0)) -(pall : Polynomial ℝ → Prop := (fun p : Polynomial ℝ => pform p ∧ pzeros p ∧ p.coeff 2 > 0)) +(pform pzeros pall : Polynomial ℝ → Prop) +(hpform : pform = (fun p : Polynomial ℝ => p.degree = 2 ∧ ∀ i ∈ Finset.range 3, p.coeff i = round (p.coeff i))) +(hpzeros : pzeros = (fun p : Polynomial ℝ => ∃ z1 z2 : Set.Ioo (0 : ℝ) 1, z1 ≠ z2 ∧ p.eval z1.1 = 0 ∧ p.eval z2.1 = 0)) +(hpall : pall = (fun p : Polynomial ℝ => pform p ∧ pzeros p ∧ p.coeff 2 > 0)) : (∃ p : Polynomial ℝ, pall p ∧ p.coeff 2 = putnam_1967_a3_solution) ∧ (∀ p : Polynomial ℝ, pall p → p.coeff 2 ≥ putnam_1967_a3_solution) := sorry diff --git a/lean4/src/putnam_1967_a6.lean b/lean4/src/putnam_1967_a6.lean index 46f7162b..0163a81c 100644 --- a/lean4/src/putnam_1967_a6.lean +++ b/lean4/src/putnam_1967_a6.lean @@ -6,7 +6,8 @@ open Nat Topology Filter abbrev putnam_1967_a6_solution : ℕ := sorry -- 8 theorem putnam_1967_a6 -(abneq0 : (Fin 4 → ℝ) → (Fin 4 → ℝ) → Prop := (fun a b : Fin 4 → ℝ => a 0 * b 1 - a 1 * b 0 ≠ 0)) +(abneq0 : (Fin 4 → ℝ) → (Fin 4 → ℝ) → Prop) +(habneq0 : abneq0 = (fun a b : Fin 4 → ℝ => a 0 * b 1 - a 1 * b 0 ≠ 0)) (numtuples : (Fin 4 → ℝ) → (Fin 4 → ℝ) → ℕ) (hnumtuples : ∀ a b : Fin 4 → ℝ, numtuples a b = {s : Fin 4 → ℝ | ∃ x : Fin 4 → ℝ, (∀ i : Fin 4, x i ≠ 0) ∧ (∑ i : Fin 4, a i * x i) = 0 ∧ (∑ i : Fin 4, b i * x i) = 0 ∧ (∀ i : Fin 4, s i = Real.sign (x i))}.encard) : (∃ a b : Fin 4 → ℝ, abneq0 a b ∧ numtuples a b = putnam_1967_a6_solution) ∧ (∀ a b : Fin 4 → ℝ, abneq0 a b → numtuples a b ≤ putnam_1967_a6_solution) := diff --git a/lean4/src/putnam_1967_b1.lean b/lean4/src/putnam_1967_b1.lean index 2b9032a4..fa73c2f6 100644 --- a/lean4/src/putnam_1967_b1.lean +++ b/lean4/src/putnam_1967_b1.lean @@ -6,9 +6,10 @@ open Nat Topology Filter theorem putnam_1967_b1 (r : ℝ) (L : ZMod 6 → (EuclideanSpace ℝ (Fin 2))) -(P : EuclideanSpace ℝ (Fin 2) := midpoint ℝ (L 1) (L 2)) -(Q : EuclideanSpace ℝ (Fin 2) := midpoint ℝ (L 3) (L 4)) -(R : EuclideanSpace ℝ (Fin 2) := midpoint ℝ (L 5) (L 0)) +(P Q R: EuclideanSpace ℝ (Fin 2)) +(hP : P = midpoint ℝ (L 1) (L 2)) +(hQ : Q = midpoint ℝ (L 3) (L 4)) +(hR : R = midpoint ℝ (L 5) (L 0)) (hr : r > 0) (hcyclic : ∃ (O : EuclideanSpace ℝ (Fin 2)), ∀ i : ZMod 6, dist O (L i) = r) (horder : ∀ i j : ZMod 6, i + 1 = j ∨ i = j + 1 ∨ segment ℝ (L i) (L j) ∩ interior (convexHull ℝ {L k | k : ZMod 6}) ≠ ∅) diff --git a/lean4/src/putnam_1968_a5.lean b/lean4/src/putnam_1968_a5.lean index a92e70ba..52af1f09 100644 --- a/lean4/src/putnam_1968_a5.lean +++ b/lean4/src/putnam_1968_a5.lean @@ -6,6 +6,7 @@ open Finset Polynomial abbrev putnam_1968_a5_solution : ℝ := sorry -- 8 theorem putnam_1968_a5 -(V : Set ℝ[X] := {P : ℝ[X] | P.degree = 2 ∧ ∀ x ∈ Set.Icc 0 1, |P.eval x| ≤ 1}) +(V : Set ℝ[X]) +(V_def : V = {P : ℝ[X] | P.degree = 2 ∧ ∀ x ∈ Set.Icc 0 1, |P.eval x| ≤ 1}) : sSup {|(derivative P).eval 0| | P ∈ V} = putnam_1968_a5_solution := sorry diff --git a/lean4/src/putnam_1969_a2.lean b/lean4/src/putnam_1969_a2.lean index 87146c59..6cc6bdc2 100644 --- a/lean4/src/putnam_1969_a2.lean +++ b/lean4/src/putnam_1969_a2.lean @@ -4,6 +4,7 @@ open BigOperators open Matrix Filter Topology Set Nat theorem putnam_1969_a2 -(D : (n : ℕ) → Matrix (Fin n) (Fin n) ℝ := fun n => λ i j => |i.1 - j.1| ) +(D : (n : ℕ) → Matrix (Fin n) (Fin n) ℝ) +(hD : D = fun (n : ℕ) => λ (i : Fin n) (j : Fin n) => |(i : ℝ) - (j : ℝ)| ) : ∀ n, n ≥ 2 → (D n).det = (-1)^((n : ℤ)-1) * ((n : ℤ)-1) * 2^((n : ℤ)-2) := sorry diff --git a/lean4/src/putnam_1969_b2.lean b/lean4/src/putnam_1969_b2.lean index 3487ff78..df4e651e 100644 --- a/lean4/src/putnam_1969_b2.lean +++ b/lean4/src/putnam_1969_b2.lean @@ -8,6 +8,7 @@ abbrev putnam_1969_b2_solution : Prop := sorry theorem putnam_1969_b2 (G : Type*) [Group G] [Finite G] -(h : ℕ → Prop := fun n => ∃ H : Fin n → Subgroup G, (∀ i : Fin n, (H i) < ⊤) ∧ ((⊤ : Set G) = ⋃ i : Fin n, (H i))) +(h : ℕ → Prop) +(h_def : h = fun n => ∃ H : Fin n → Subgroup G, (∀ i : Fin n, (H i) < ⊤) ∧ ((⊤ : Set G) = ⋃ i : Fin n, (H i))) : ¬(h 2) ∧ ((¬(h 3)) ↔ putnam_1969_b2_solution) := sorry diff --git a/lean4/src/putnam_1969_b5.lean b/lean4/src/putnam_1969_b5.lean index 462bf9f6..30d837e5 100644 --- a/lean4/src/putnam_1969_b5.lean +++ b/lean4/src/putnam_1969_b5.lean @@ -7,5 +7,7 @@ theorem putnam_1969_b5 (a : ℕ → ℝ) (ha : StrictMono a ∧ (∀ x : ℕ, a > 0)) (hinvasum : ∃ C : ℝ, Tendsto (fun n => ∑ i : Fin n, 1/(a i)) atTop (𝓝 C)) -(k : ℝ → ℕ := fun x => {n | a n ≤ x}.ncard) -: Tendsto (fun t => (k t)/t) atTop (𝓝 0) := sorry +(k : ℝ → ℕ) +(hk : k = fun x => {n | a n ≤ x}.ncard) +: Tendsto (fun t => (k t)/t) atTop (𝓝 0) := +sorry diff --git a/lean4/src/putnam_1970_a1.lean b/lean4/src/putnam_1970_a1.lean index d49de4a7..d33e778f 100644 --- a/lean4/src/putnam_1970_a1.lean +++ b/lean4/src/putnam_1970_a1.lean @@ -7,7 +7,8 @@ theorem putnam_1970_a1 (a b : ℝ) (ha : a > 0) (hb : b > 0) -(f : ℝ → ℝ := fun x : ℝ => Real.exp (a*x) * Real.cos (b*x)) +(f : ℝ → ℝ) +(f_def : f = fun x : ℝ => Real.exp (a*x) * Real.cos (b*x)) (p : ℕ → ℝ) (hp : ∃ c : ℝ, c > 0 ∧ ∀ x ∈ ball 0 c, ∑' n : ℕ, (p n)*x^n = f x) (S : Set ℕ := {n : ℕ | p n = 0}) diff --git a/lean4/src/putnam_1970_b5.lean b/lean4/src/putnam_1970_b5.lean index aca8c63a..0785e818 100644 --- a/lean4/src/putnam_1970_b5.lean +++ b/lean4/src/putnam_1970_b5.lean @@ -4,7 +4,8 @@ open BigOperators open Metric Set EuclideanGeometry Filter Topology theorem putnam_1970_b5 -(ramp : ℤ → (ℝ → ℝ) := fun n => (fun x => if x ≤ -n then -n else (if -n < x ∧ x ≤ n then x else n))) +(ramp : ℤ → (ℝ → ℝ)) +(ramp_def : ramp = fun (n : ℤ) => (fun (x : ℝ) => if x ≤ -n then (-n : ℝ) else (if -n < x ∧ x ≤ n then x else (n : ℝ)))) (F : ℝ → ℝ) : Continuous F ↔ (∀ n : ℕ, Continuous ((ramp n) ∘ F)) := sorry diff --git a/lean4/src/putnam_1970_b6.lean b/lean4/src/putnam_1970_b6.lean index 065d54ed..a2f5c211 100644 --- a/lean4/src/putnam_1970_b6.lean +++ b/lean4/src/putnam_1970_b6.lean @@ -5,7 +5,8 @@ open Metric Set EuclideanGeometry Filter Topology theorem putnam_1970_b6 (L : ZMod 4 → (EuclideanSpace ℝ (Fin 2))) -(S : Set (EuclideanSpace ℝ (Fin 2)) := {L i | i : ZMod 4}) +(S : Set (EuclideanSpace ℝ (Fin 2))) +(S_def : S = {L i | i : ZMod 4}) (hSquad : S.ncard = 4 ∧ ∀ s ⊆ S, s.ncard = 3 → ¬ Collinear ℝ s) (hlens : dist (L 0) (L 1) > 0 ∧ dist (L 1) (L 2) > 0 ∧ dist (L 2) (L 3) > 0 ∧ dist (L 3) (L 0) > 0) (horder : ∀ i : ZMod 4, segment ℝ (L i) (L (i + 1)) ∩ interior (convexHull ℝ S) = ∅) diff --git a/lean4/src/putnam_1971_a1.lean b/lean4/src/putnam_1971_a1.lean index 5482ecc8..ebc4aae3 100644 --- a/lean4/src/putnam_1971_a1.lean +++ b/lean4/src/putnam_1971_a1.lean @@ -6,7 +6,8 @@ open Set theorem putnam_1971_a1 (S : Set (ℤ × ℤ × ℤ)) (hS : S.ncard = 9) -(L : (ℤ × ℤ × ℤ) × (ℤ × ℤ × ℤ) → Set (ℝ × ℝ × ℝ) := fun ((a, b, c), (d, e, f)) => +(L : (ℤ × ℤ × ℤ) × (ℤ × ℤ × ℤ) → Set (ℝ × ℝ × ℝ)) +(hL : L = fun ((a, b, c), (d, e, f)) => {(t*a + (1-t)*d, t*b + (1-t)*e, t*c + (1-t)*f) | t ∈ Ioo (0 : ℝ) 1}) : ∃ x y z : ℤ, ∃ P Q : ℤ × ℤ × ℤ, P ∈ S ∧ Q ∈ S ∧ P ≠ Q ∧ ((x : ℝ), (y : ℝ), (z : ℝ)) ∈ L (P, Q) := sorry diff --git a/lean4/src/putnam_1971_a3.lean b/lean4/src/putnam_1971_a3.lean index 68db8076..db9534fd 100644 --- a/lean4/src/putnam_1971_a3.lean +++ b/lean4/src/putnam_1971_a3.lean @@ -9,7 +9,8 @@ theorem putnam_1971_a3 (habclattice : a.1 = round a.1 ∧ a.2 = round a.2 ∧ b.1 = round b.1 ∧ b.2 = round b.2 ∧ c.1 = round c.1 ∧ c.2 = round c.2) (habcneq : a ≠ b ∧ a ≠ c ∧ b ≠ c) (hR : R > 0) -(oncircle : (ℝ × ℝ) → ℝ → (ℝ × ℝ) → Prop := fun C r p => Real.sqrt ((p.1 - C.1)^2 + (p.2 - C.2)^2) = r) +(oncircle : (ℝ × ℝ) → ℝ → (ℝ × ℝ) → Prop) +(oncircle_def : on_circle = fun (C : ℝ × ℝ) (r : ℝ) (p : ℝ × ℝ) => Real.sqrt ((p.1 - C.1)^2 + (p.2 - C.2)^2) = r) (hcircle : ∃ C : ℝ × ℝ, oncircle C R a ∧ oncircle C R b ∧ oncircle C R c) : (Real.sqrt ((a.1 - b.1)^2 + (a.2 - b.2)^2)) * (Real.sqrt ((a.1 - c.1)^2 + (a.2 - c.2)^2)) * (Real.sqrt ((b.1 - c.1)^2 + (b.2 - c.2)^2)) ≥ 2 * R := sorry diff --git a/lean4/src/putnam_1971_a4.lean b/lean4/src/putnam_1971_a4.lean index e1d9e575..7a3671ef 100644 --- a/lean4/src/putnam_1971_a4.lean +++ b/lean4/src/putnam_1971_a4.lean @@ -6,6 +6,7 @@ open Set MvPolynomial theorem putnam_1971_a4 (ε : ℝ) (hε : 0 < ε ∧ ε < 1) -(P : ℕ → ℝ → MvPolynomial (Fin 2) ℝ := fun n δ => (MvPolynomial.X 0 + MvPolynomial.X 1)^n * ((MvPolynomial.X 0)^2 - (MvPolynomial.C (2 - δ))*(MvPolynomial.X 0)*(MvPolynomial.X 1) + (MvPolynomial.X 1)^2)) +(P : ℕ → ℝ → MvPolynomial (Fin 2) ℝ) +(hP : P = fun (n : ℕ) (δ : ℝ) => (MvPolynomial.X 0 + MvPolynomial.X 1)^n * ((MvPolynomial.X 0)^2 - (MvPolynomial.C (2 - δ))*(MvPolynomial.X 0)*(MvPolynomial.X 1) + (MvPolynomial.X 1)^2)) : ∃ N : ℕ, ∀ n ≥ N, ∀ i : Fin 2 →₀ ℕ, MvPolynomial.coeff i (P n ε) ≥ 0 := sorry diff --git a/lean4/src/putnam_1971_a5.lean b/lean4/src/putnam_1971_a5.lean index 7b61ac61..6a05e11b 100644 --- a/lean4/src/putnam_1971_a5.lean +++ b/lean4/src/putnam_1971_a5.lean @@ -8,6 +8,7 @@ abbrev putnam_1971_a5_solution : ℤ × ℤ := sorry theorem putnam_1971_a5 (a b : ℤ) (hab : a > 0 ∧ b > 0 ∧ a > b) -(pab : ℤ → ℤ → Prop := fun x y : ℤ ↦ {s : ℕ | ¬∃ m n : ℕ, m*x + n*y = s}.ncard = 35 ∧ ¬∃ m n : ℕ, m*x + n*y = 58) +(pab : ℤ → ℤ → Prop) +(hpab : pab = fun x y : ℤ ↦ {s : ℕ | ¬∃ m n : ℕ, m*x + n*y = s}.ncard = 35 ∧ ¬∃ m n : ℕ, m*x + n*y = 58) : pab a b ↔ a = putnam_1971_a5_solution.1 ∧ b = putnam_1971_a5_solution.2 := sorry diff --git a/lean4/src/putnam_1971_b2.lean b/lean4/src/putnam_1971_b2.lean index b785afa8..a4c84b34 100644 --- a/lean4/src/putnam_1971_b2.lean +++ b/lean4/src/putnam_1971_b2.lean @@ -6,7 +6,8 @@ open Set MvPolynomial abbrev putnam_1971_b2_solution : Set (ℝ → ℝ) := sorry -- {fun x : ℝ => (x^3 - x^2 - 1)/(2 * x * (x - 1))} theorem putnam_1971_b2 -(S : Set ℝ := univ \ {0, 1}) +(S : Set ℝ) +(hS : S = univ \ {0, 1}) (P : (ℝ → ℝ) → Prop := fun (F : ℝ → ℝ) => ∀ x ∈ S, F x + F ((x - 1)/x) = 1 + x) : (∀ F ∈ putnam_1971_b2_solution, P F) ∧ ∀ f : ℝ → ℝ, P f → ∃ F ∈ putnam_1971_b2_solution, (∀ x ∈ S, f x = F x) := sorry diff --git a/lean4/src/putnam_1971_b6.lean b/lean4/src/putnam_1971_b6.lean index fb48e367..9d18b7ad 100644 --- a/lean4/src/putnam_1971_b6.lean +++ b/lean4/src/putnam_1971_b6.lean @@ -4,6 +4,7 @@ open BigOperators open Set MvPolynomial theorem putnam_1971_b6 -(δ : ℤ → ℤ := fun n => sSup {t | Odd t ∧ t ∣ n}) +(δ : ℤ → ℤ) +(hδ : δ = fun n => sSup {t | Odd t ∧ t ∣ n}) : ∀ x : ℤ, x > 0 → |∑ i in Finset.Icc 1 x, (δ i)/(i : ℚ) - 2*x/3| < 1 := sorry diff --git a/lean4/src/putnam_1972_a1.lean b/lean4/src/putnam_1972_a1.lean index 738dd313..ca2320ae 100644 --- a/lean4/src/putnam_1972_a1.lean +++ b/lean4/src/putnam_1972_a1.lean @@ -6,6 +6,7 @@ open EuclideanGeometry Filter Topology Set theorem putnam_1972_a1 (n : ℕ) (hn : n > 0) -(fourAP : ℤ → ℤ → ℤ → ℤ → Prop := fun n1 n2 n3 n4 => n4-n3 = n3-n2 ∧ n3-n2 = n2-n1) +(fourAP : ℤ → ℤ → ℤ → ℤ → Prop) +(hfourAP : fourAP = fun n1 n2 n3 n4 => n4-n3 = n3-n2 ∧ n3-n2 = n2-n1) : ¬ ∃ r : ℕ, r > 0 ∧ r + 3 ≤ n ∧ fourAP (n.choose r) (n.choose (r+1)) (n.choose (r+2)) (n.choose (r+3)) := sorry diff --git a/lean4/src/putnam_1972_a3.lean b/lean4/src/putnam_1972_a3.lean index db231eb7..661cabbb 100644 --- a/lean4/src/putnam_1972_a3.lean +++ b/lean4/src/putnam_1972_a3.lean @@ -7,7 +7,9 @@ open EuclideanGeometry Filter Topology Set abbrev putnam_1972_a3_solution : Set (ℝ → ℝ) := sorry -- {f | ∃ A B : ℝ, ∀ x ∈ Set.Icc 0 1, f x = A * x + B} theorem putnam_1972_a3 -(climit_exists : (ℕ → ℝ) → Prop := fun x => ∃ C : ℝ, Tendsto (fun n => (∑ i in Finset.range n, (x i))/(n : ℝ)) atTop (𝓝 C)) -(supercontinuous : (ℝ → ℝ) → Prop := fun f => ∀ (x : ℕ → ℝ), (∀ i : ℕ, x i ∈ Icc 0 1) → climit_exists x → climit_exists (fun i => f (x i))) +(climit_exists : (ℕ → ℝ) → Prop) +(hclimit_exists : climit_exists = fun x => ∃ C : ℝ, Tendsto (fun n => (∑ i in Finset.range n, (x i))/(n : ℝ)) atTop (𝓝 C)) +(supercontinuous : (ℝ → ℝ) → Prop) +(hsupercontinuous : supercontinuous = fun f => ∀ (x : ℕ → ℝ), (∀ i : ℕ, x i ∈ Icc 0 1) → climit_exists x → climit_exists (fun i => f (x i))) : {f | supercontinuous f} = putnam_1972_a3_solution := sorry diff --git a/lean4/src/putnam_1972_b1.lean b/lean4/src/putnam_1972_b1.lean index 6cbcfd48..58934fe2 100644 --- a/lean4/src/putnam_1972_b1.lean +++ b/lean4/src/putnam_1972_b1.lean @@ -4,7 +4,8 @@ open BigOperators open EuclideanGeometry Filter Topology Set MeasureTheory Metric theorem putnam_1972_b1 -(S : ℝ → ℝ := fun x : ℝ => ∑' n : ℕ, x^n * (x - 1)^(2*n) / (Nat.factorial n)) +(S : ℝ → ℝ) +(hS : S = fun (x : ℝ) => ∑' n : ℕ, x^n * (x - 1)^(2*n) / (Nat.factorial n)) (p : ℕ → ℝ) (hp : ∃ a : ℝ, a > 0 ∧ ∀ x ∈ ball 0 a, ∑' n : ℕ, (p n)*x^n = S x) : ¬∃ n : ℕ, p n = 0 ∧ p (n + 1) = 0 ∧ p (n + 2) = 0 := diff --git a/lean4/src/putnam_1972_b2.lean b/lean4/src/putnam_1972_b2.lean index ccceada1..e200d77d 100644 --- a/lean4/src/putnam_1972_b2.lean +++ b/lean4/src/putnam_1972_b2.lean @@ -9,7 +9,8 @@ theorem putnam_1972_b2 (s v : ℝ) (hs : s > 0) (hv : v > 0) -(valid : ℝ → (ℝ → ℝ) → Prop := fun (t : ℝ) (x : ℝ → ℝ) ↦ +(valid : ℝ → (ℝ → ℝ) → Prop) +(hvalid : valid = fun (t : ℝ) (x : ℝ → ℝ) ↦ DifferentiableOn ℝ x (Set.Icc 0 t) ∧ DifferentiableOn ℝ (deriv x) (Set.Icc 0 t) ∧ AntitoneOn (deriv (deriv x)) (Set.Icc 0 t) ∧ deriv x 0 = 0 ∧ deriv x t = v ∧ x t - x 0 = s) : (∃ x : ℝ → ℝ, valid (putnam_1972_b2_solution s v) x) ∧ diff --git a/lean4/src/putnam_1972_b4.lean b/lean4/src/putnam_1972_b4.lean index 212b6ccd..2489cc57 100644 --- a/lean4/src/putnam_1972_b4.lean +++ b/lean4/src/putnam_1972_b4.lean @@ -6,6 +6,7 @@ open EuclideanGeometry Filter Topology Set MeasureTheory Metric theorem putnam_1972_b4 (n : ℕ) (hn : n > 1) -(vars : ℤ → ℤ → ℤ → (Fin 3 → ℤ) := fun a b c ↦ fun i ↦ ite (i = 0) a (ite (i = 1) b c)) +(vars : ℤ → ℤ → ℤ → (Fin 3 → ℤ)) +(hvars : vars = fun a b c ↦ fun i ↦ ite (i = 0) a (ite (i = 1) b c)) : ∃ P : MvPolynomial (Fin 3) ℤ, ∀ x : ℤ, x = MvPolynomial.eval (vars (x^n) (x^(n+1)) (x + x^(n+2))) P := sorry diff --git a/lean4/src/putnam_1972_b6.lean b/lean4/src/putnam_1972_b6.lean index 2fd6fc5c..5a6755ed 100644 --- a/lean4/src/putnam_1972_b6.lean +++ b/lean4/src/putnam_1972_b6.lean @@ -9,6 +9,7 @@ theorem putnam_1972_b6 (n : Fin k → ℤ) (hn : ∀ i : Fin k, n i > 0) (hn' : ∀ i j : Fin k, i < j → n i < n j) -(zpoly : ℂ → ℂ := fun z => 1 + ∑ i : Fin k, z^(n i)) +(zpoly : ℂ → ℂ) +(hzpoly : zpoly = fun z => 1 + ∑ i : Fin k, z^(n i)) : ∀ z : ℂ, z ∈ ball 0 ((Real.sqrt 5 - 1)/2) → zpoly z ≠ 0 := sorry diff --git a/lean4/src/putnam_1973_a2.lean b/lean4/src/putnam_1973_a2.lean index 6db99c4a..905a21d6 100644 --- a/lean4/src/putnam_1973_a2.lean +++ b/lean4/src/putnam_1973_a2.lean @@ -8,7 +8,9 @@ abbrev putnam_1973_a2_solution : Prop := sorry theorem putnam_1973_a2 (L : List ℝ) (hL : L.length = 8 ∧ ∀ i : Fin L.length, L[i] = 1 ∨ L[i] = -1) -(pluses : ℕ := {i : Fin L.length | L[i] = 1}.ncard) -(S : ℕ → ℝ := fun n : ℕ ↦ ∑ i in Finset.Icc 1 n, L[i % 8]/i) +(pluses : ℕ) +(hpluses : pluses = {i : Fin L.length | L[i] = 1}.ncard) +(S : ℕ → ℝ) +(hS : S = fun n : ℕ ↦ ∑ i in Finset.Icc 1 n, L[i % 8]/i) : (pluses = 4 → ∃ l : ℝ, Tendsto S atTop (𝓝 l)) ∧ (putnam_1973_a2_solution ↔ ((∃ l : ℝ, Tendsto S atTop (𝓝 l)) → pluses = 4)) := sorry diff --git a/lean4/src/putnam_1973_a3.lean b/lean4/src/putnam_1973_a3.lean index 8dd693d7..645370ff 100644 --- a/lean4/src/putnam_1973_a3.lean +++ b/lean4/src/putnam_1973_a3.lean @@ -4,6 +4,7 @@ open BigOperators open Nat Set MeasureTheory Topology Filter theorem putnam_1973_a3 -(b : ℤ → ℝ := fun n => sInf {k + (n : ℝ)/(k : ℝ) | k > (0 : ℤ)}) +(b : ℤ → ℝ) +(hb : b = fun (n : ℤ) => sInf {k + (n : ℝ)/(k : ℝ) | k > (0 : ℤ)}) : ∀ n : ℤ, n > 0 → floor (b n) = floor (Real.sqrt (4 * n + 1)) := sorry diff --git a/lean4/src/putnam_1973_a4.lean b/lean4/src/putnam_1973_a4.lean index 1c23ae95..474cfa06 100644 --- a/lean4/src/putnam_1973_a4.lean +++ b/lean4/src/putnam_1973_a4.lean @@ -6,6 +6,7 @@ open Nat Set MeasureTheory Topology Filter abbrev putnam_1973_a4_solution : ℕ := sorry -- 3 theorem putnam_1973_a4 -(f : ℝ → ℝ := fun x => 2^x - 1 - x^2) +(f : ℝ → ℝ) +(hf : f = fun x => 2^x - 1 - x^2) : putnam_1973_a4_solution = {x : ℝ | f x = 0}.ncard := sorry diff --git a/lean4/src/putnam_1973_a6.lean b/lean4/src/putnam_1973_a6.lean index 0c749505..e291393a 100644 --- a/lean4/src/putnam_1973_a6.lean +++ b/lean4/src/putnam_1973_a6.lean @@ -5,6 +5,7 @@ open Nat Set MeasureTheory Topology Filter -- Note: Uses the slope/intercept formulation of line in the plane theorem putnam_1973_a6 -(h_nint : ℕ → (Fin 7 → (ℝ × ℝ)) → ℕ := fun n lines => {p : ℝ × ℝ | ∃! S : Set (Fin 7), S.ncard = n ∧ p ∈ ⋂ i ∈ S, {pts | pts.2 = (lines i).1 * pts.1 + (lines i).2}}.ncard) -: ¬ ∃ lines : Fin 7 → (ℝ × ℝ), (∀ i j : Fin 7, i ≠ j → lines i ≠ lines j) ∧ h_nint 3 lines ≥ 6 ∧ h_nint 2 lines ≥ 4 := +(nint : ℕ → (Fin 7 → (ℝ × ℝ)) → ℕ) +(h_nint : nint = fun n lines => {p : ℝ × ℝ | ∃! S : Set (Fin 7), S.ncard = n ∧ p ∈ ⋂ i ∈ S, {pts | pts.2 = (lines i).1 * pts.1 + (lines i).2}}.ncard) +: ¬ ∃ lines : Fin 7 → (ℝ × ℝ), (∀ i j : Fin 7, i ≠ j → lines i ≠ lines j) ∧ nint 3 lines ≥ 6 ∧ nint 2 lines ≥ 4 := sorry diff --git a/lean4/src/putnam_1973_b4.lean b/lean4/src/putnam_1973_b4.lean index c9924c6e..506941d7 100644 --- a/lean4/src/putnam_1973_b4.lean +++ b/lean4/src/putnam_1973_b4.lean @@ -8,7 +8,8 @@ abbrev putnam_1973_b4_solution : ℝ → ℝ := sorry -- (fun x => x) theorem putnam_1973_b4 (f : ℝ → ℝ) -(hprop : (ℝ → ℝ) → Prop := fun g => ContDiff ℝ 1 g ∧ (∀ x : ℝ, 0 < deriv g x ∧ deriv g x ≤ 1) ∧ g 0 = 0) +(hprop : (ℝ → ℝ) → Prop) +(hprop_def : hprop = fun g => ContDiff ℝ 1 g ∧ (∀ x : ℝ, 0 < deriv g x ∧ deriv g x ≤ 1) ∧ g 0 = 0) (hf : hprop f) : (∫ x in Icc 0 1, f x)^2 ≥ ∫ x in Icc 0 1, (f x)^3 ∧ (hprop putnam_1973_b4_solution ∧ (∫ x in Icc 0 1, putnam_1973_b4_solution x)^2 = ∫ x in Icc 0 1, (putnam_1973_b4_solution x)^3) := sorry diff --git a/lean4/src/putnam_1974_a1.lean b/lean4/src/putnam_1974_a1.lean index 3415147a..32eeb159 100644 --- a/lean4/src/putnam_1974_a1.lean +++ b/lean4/src/putnam_1974_a1.lean @@ -6,5 +6,7 @@ open Set abbrev putnam_1974_a1_solution : ℕ := sorry -- 11 theorem putnam_1974_a1 -(conspiratorial : Set ℤ → Prop := fun S => ∀ a ∈ S, ∀ b ∈ S, ∀ c ∈ S, (a > 0 ∧ b > 0 ∧ c > 0) ∧ ((a ≠ b ∧ b ≠ c ∧ a ≠ c) → (Int.gcd a b > 1 ∨ Int.gcd b c > 1 ∨ Int.gcd a c > 1))) -: (∀ S : Set ℤ, S ⊆ Icc 1 16 → conspiratorial S → S.encard ≤ putnam_1974_a1_solution) ∧ (∃ S : Set ℤ, S ⊆ Icc 1 16 ∧ conspiratorial S ∧ S.encard = putnam_1974_a1_solution) := sorry +(conspiratorial : Set ℤ → Prop) +(hconspiratorial : conspiratorial = fun S => ∀ a ∈ S, ∀ b ∈ S, ∀ c ∈ S, (a > 0 ∧ b > 0 ∧ c > 0) ∧ ((a ≠ b ∧ b ≠ c ∧ a ≠ c) → (Int.gcd a b > 1 ∨ Int.gcd b c > 1 ∨ Int.gcd a c > 1))) +: (∀ S : Set ℤ, S ⊆ Icc 1 16 → conspiratorial S → S.encard ≤ putnam_1974_a1_solution) ∧ (∃ S : Set ℤ, S ⊆ Icc 1 16 ∧ conspiratorial S ∧ S.encard = putnam_1974_a1_solution) := +sorry diff --git a/lean4/src/putnam_1974_a6.lean b/lean4/src/putnam_1974_a6.lean index 7ad357fa..a313c8bd 100644 --- a/lean4/src/putnam_1974_a6.lean +++ b/lean4/src/putnam_1974_a6.lean @@ -6,7 +6,7 @@ open Set Nat Polynomial abbrev putnam_1974_a6_solution : ℕ := sorry -- 25 theorem putnam_1974_a6 -(n : ℤ := 10^6) -(hdivnallx : Polynomial ℤ → Prop := fun f => Monic f ∧ (∀ x : ℤ, (n : ℤ) ∣ f.eval x)) +(hdivnallx : Polynomial ℤ → Prop) +(hdivnallx_def : hdivnallx = fun f => Monic f ∧ (∀ x : ℤ, (10^6 : ℤ) ∣ f.eval x)) : sInf {d : ℕ | ∃ f : Polynomial ℤ, hdivnallx f ∧ d = f.natDegree} = putnam_1974_a6_solution := sorry diff --git a/lean4/src/putnam_1974_b1.lean b/lean4/src/putnam_1974_b1.lean index 54809211..ca7f8c09 100644 --- a/lean4/src/putnam_1974_b1.lean +++ b/lean4/src/putnam_1974_b1.lean @@ -6,7 +6,9 @@ open Set Nat Polynomial abbrev putnam_1974_b1_solution : (Fin 5 → (ℝ × ℝ)) -> Prop := sorry -- fun points => (∃ (B : ℝ) (ordering : Equiv.Perm (Fin 5)), ∀ i : Fin 5, Real.sqrt (((points (ordering i)).1 - (points (ordering (i+1))).1)^2 + ((points (ordering i)).2 - (points (ordering (i+1))).2)^2) = B) theorem putnam_1974_b1 -(on_unit_circle : (Fin 5 → (ℝ × ℝ)) -> Prop := fun points => ∀ i : Fin 5, Real.sqrt ((points i).1^2 + (points i).2^2) = 1) -(distance_fun : (Fin 5 → (ℝ × ℝ)) -> ℝ := fun points => ∑ idx : Fin 5 × Fin 5, if idx.1 < idx.2 then Real.sqrt (((points idx.1).1 - (points idx.2).1)^2 + ((points idx.1).2 - (points idx.2).2)^2) else 0) +(on_unit_circle : (Fin 5 → (ℝ × ℝ)) -> Prop) +(distance_fun : (Fin 5 → (ℝ × ℝ)) -> ℝ) +(h_on_unit_circle : on_unit_circle = fun points => ∀ i : Fin 5, Real.sqrt ((points i).1^2 + (points i).2^2) = 1) +(hdistance_fun : distance_fun = fun points => ∑ idx : Fin 5 × Fin 5, if idx.1 < idx.2 then Real.sqrt (((points idx.1).1 - (points idx.2).1)^2 + ((points idx.1).2 - (points idx.2).2)^2) else 0) : ∀ points : Fin 5 → (ℝ × ℝ), on_unit_circle points → (distance_fun points = sSup {R | ∃ pts, on_unit_circle pts ∧ R = distance_fun pts} ↔ putnam_1974_b1_solution points) := sorry diff --git a/lean4/src/putnam_1974_b6.lean b/lean4/src/putnam_1974_b6.lean index 4d956467..9f5923e0 100644 --- a/lean4/src/putnam_1974_b6.lean +++ b/lean4/src/putnam_1974_b6.lean @@ -7,8 +7,9 @@ abbrev putnam_1974_b6_solution : (ℕ × ℕ × ℕ) := sorry -- ((2^1000 - 1)/3, (2^1000 - 1)/3, 1 + (2^1000 - 1)/3) theorem putnam_1974_b6 (n : ℤ := 1000) -(count0 : ℕ := {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 0 [MOD 3]}.ncard) -(count1 : ℕ := {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 1 [MOD 3]}.ncard) -(count2 : ℕ := {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 2 [MOD 3]}.ncard) +(count0 count1 count2 : ℕ) +(hcount0 : count0 = {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 0 [MOD 3]}.ncard) +(hcount1 : count1 = {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 1 [MOD 3]}.ncard) +(hcount2 : count2 = {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 2 [MOD 3]}.ncard) : (count0, count1, count2) = putnam_1974_b6_solution := sorry diff --git a/lean4/src/putnam_1975_a1.lean b/lean4/src/putnam_1975_a1.lean index 8f5fbb9a..9e8606c1 100644 --- a/lean4/src/putnam_1975_a1.lean +++ b/lean4/src/putnam_1975_a1.lean @@ -6,8 +6,9 @@ open Polynomial abbrev putnam_1975_a1_solution : ((ℤ × ℤ) → ℤ) × ((ℤ × ℤ) → ℤ) := sorry -- (fun (a, b) => a + b + 1, fun (a, b) => a - b) theorem putnam_1975_a1 -(nab : (ℤ × ℤ × ℤ) → Prop := fun (n, a, b) => n = (a^2 + (a : ℚ))/2 + (b^2 + (b : ℚ))/2) -(nxy : (ℤ × ℤ × ℤ) → Prop := fun (n, x, y) => 4*n + 1 = x^2 + y^2) +(nab nxy : (ℤ × ℤ × ℤ) → Prop) +(hnab : nab = fun (n, a, b) => n = (a^2 + (a : ℚ))/2 + (b^2 + (b : ℚ))/2) +(hnxy : nxy = fun (n, x, y) => 4*n + 1 = x^2 + y^2) : (∀ n a b : ℤ, nab (n, a, b) → nxy (n, putnam_1975_a1_solution.1 (a, b), putnam_1975_a1_solution.2 (a, b))) ∧ ∀ n : ℤ, (∃ x y : ℤ, nxy (n, x, y)) → ∃ a b : ℤ, nab (n, a, b) := sorry diff --git a/lean4/src/putnam_1975_a3.lean b/lean4/src/putnam_1975_a3.lean index a8b6d49f..f516c54e 100644 --- a/lean4/src/putnam_1975_a3.lean +++ b/lean4/src/putnam_1975_a3.lean @@ -8,8 +8,10 @@ noncomputable abbrev putnam_1975_a3_solution : ((ℝ × ℝ × ℝ) → (ℝ × theorem putnam_1975_a3 (a b c : ℝ) (hi : 0 < a ∧ a < b ∧ b < c) -(P : (ℝ × ℝ × ℝ) → Prop := fun (x, y, z) => x ≥ 0 ∧ y ≥ 0 ∧ z ≥ 0 ∧ x^b + y^b + z^b = 1) -(f : (ℝ × ℝ × ℝ) → ℝ := fun (x, y, z) => x^a + y^b + z^c) +(P : (ℝ × ℝ × ℝ) → Prop) +(f : (ℝ × ℝ × ℝ) → ℝ) +(hP : P = fun (x, y, z) => x ≥ 0 ∧ y ≥ 0 ∧ z ≥ 0 ∧ x^b + y^b + z^b = 1) +(hf : f = fun (x, y, z) => x^a + y^b + z^c) : (P (putnam_1975_a3_solution.1 (a, b, c)) ∧ ∀ x y z : ℝ, P (x, y, z) → f (x, y, z) ≤ f (putnam_1975_a3_solution.1 (a, b, c))) ∧ (P (putnam_1975_a3_solution.2 (a, b, c)) ∧ ∀ x y z : ℝ, P (x, y, z) → diff --git a/lean4/src/putnam_1975_a4.lean b/lean4/src/putnam_1975_a4.lean index 3ccab144..a83bf3c6 100644 --- a/lean4/src/putnam_1975_a4.lean +++ b/lean4/src/putnam_1975_a4.lean @@ -8,7 +8,7 @@ noncomputable abbrev putnam_1975_a4_solution : ℕ → Polynomial ℤ := sorry theorem putnam_1975_a4 (m : ℕ) (hm : Odd m ∧ m > 1) -(n : ℕ := 2 * m) -(θ : ℂ := cexp (2 * Real.pi * I / n)) +(θ : ℂ) +(hθ : θ = cexp (2 * Real.pi * I / (2 * m))) : 1/(1 - θ) = Polynomial.aeval θ (putnam_1975_a4_solution m) := sorry diff --git a/lean4/src/putnam_1975_b1.lean b/lean4/src/putnam_1975_b1.lean index 0e72d34f..0c61eac6 100644 --- a/lean4/src/putnam_1975_b1.lean +++ b/lean4/src/putnam_1975_b1.lean @@ -6,6 +6,7 @@ open Polynomial Real Complex abbrev putnam_1975_b1_solution : ℤ := sorry -- 7 theorem putnam_1975_b1 -(H : Set (ℤ × ℤ) := {(x, y) : (ℤ × ℤ) | ∃ u v w : ℤ, (x, y) = (u*3 + v*4 + w*5, u*8 + v*(-1) + w*4)}) +(H : Set (ℤ × ℤ)) +(hH : H = {(x, y) : (ℤ × ℤ) | ∃ u v w : ℤ, (x, y) = (u*3 + v*4 + w*5, u*8 + v*(-1) + w*4)}) : (∃ b : ℤ, H = {(x, y) : (ℤ × ℤ) | ∃ u v : ℤ, (x, y) = (u, u*b + v*putnam_1975_b1_solution)}) ∧ putnam_1975_b1_solution > 0 := sorry diff --git a/lean4/src/putnam_1975_b2.lean b/lean4/src/putnam_1975_b2.lean index eac47d3c..368e79fd 100644 --- a/lean4/src/putnam_1975_b2.lean +++ b/lean4/src/putnam_1975_b2.lean @@ -4,7 +4,8 @@ open BigOperators open Polynomial Real Complex Matrix Filter Topology theorem putnam_1975_b2 -(slab : (Fin 3 → ℝ) → ℝ → ℝ → Set (Fin 3 → ℝ) := fun normal offset thickness => {x : Fin 3 → ℝ | offset < normal ⬝ᵥ x ∧ normal ⬝ᵥ x < offset + thickness}) +(slab : (Fin 3 → ℝ) → ℝ → ℝ → Set (Fin 3 → ℝ)) +(hslab : slab = fun normal offset thickness => {x : Fin 3 → ℝ | offset < normal ⬝ᵥ x ∧ normal ⬝ᵥ x < offset + thickness}) (normals : ℕ → (Fin 3 → ℝ)) (offsets : ℕ → ℝ) (thicknesses : ℕ → ℝ) diff --git a/lean4/src/putnam_1975_b4.lean b/lean4/src/putnam_1975_b4.lean index 25253a18..551f9156 100644 --- a/lean4/src/putnam_1975_b4.lean +++ b/lean4/src/putnam_1975_b4.lean @@ -6,6 +6,7 @@ open Polynomial Real Complex Matrix Filter Topology Multiset abbrev putnam_1975_b4_solution : Prop := sorry -- False theorem putnam_1975_b4 -(P : ℝ × ℝ → Prop := fun (x, y) => x^2 + y^2 = 1) +(P : ℝ × ℝ → Prop) +(hP : P = fun (x, y) => x^2 + y^2 = 1) : (∃ B ⊆ setOf P, IsClosed B ∧ ∀ x y : ℝ, P (x, y) → Xor' ((x, y) ∈ B) ((-x, -y) ∈ B)) ↔ putnam_1975_b4_solution := sorry diff --git a/lean4/src/putnam_1975_b5.lean b/lean4/src/putnam_1975_b5.lean index e6edaed5..e9adeea2 100644 --- a/lean4/src/putnam_1975_b5.lean +++ b/lean4/src/putnam_1975_b5.lean @@ -4,7 +4,8 @@ open BigOperators open Polynomial Real Complex Matrix Filter Topology Multiset theorem putnam_1975_b5 -(e : ℝ := Real.exp 1) +(e : ℝ) +(he : e = Real.exp 1) (f : ℕ → ℝ → ℝ) (h0 : ∀ x : ℝ, f 0 x = e^x) (hf : ∀ n : ℕ, ∀ x : ℝ, f (n + 1) x = x * (deriv (f n) x)) diff --git a/lean4/src/putnam_1975_b6.lean b/lean4/src/putnam_1975_b6.lean index b7162a3a..940729bf 100644 --- a/lean4/src/putnam_1975_b6.lean +++ b/lean4/src/putnam_1975_b6.lean @@ -4,6 +4,7 @@ open BigOperators open Polynomial Real Complex Matrix Filter Topology Multiset theorem putnam_1975_b6 -(s : ℕ → ℝ := fun n => ∑ i in Finset.Icc 1 n, 1/(i : ℝ)) +(s : ℕ → ℝ) +(hs : s = fun (n : ℕ) => ∑ i in Finset.Icc 1 n, 1/(i : ℝ)) : (∀ n : ℕ, n > 1 → n * (n+1 : ℝ)^(1/(n : ℝ)) < n + s n) ∧ (∀ n : ℕ, n > 2 → ((n : ℝ) - 1)*((n : ℝ)^(-1/(n-1 : ℝ))) < n - s n) := sorry diff --git a/lean4/src/putnam_1976_a2.lean b/lean4/src/putnam_1976_a2.lean index 453b0231..e5d25655 100644 --- a/lean4/src/putnam_1976_a2.lean +++ b/lean4/src/putnam_1976_a2.lean @@ -4,10 +4,13 @@ open BigOperators open MvPolynomial theorem putnam_1976_a2 -(P : MvPolynomial (Fin 2) ℤ := (X 0)^2*(X 1) + (X 0)*(X 1)^2) -(Q : MvPolynomial (Fin 2) ℤ := (X 0)^2 + (X 0)*(X 1) + (X 2)^2) -(F : ℕ → MvPolynomial (Fin 2) ℤ := fun n : ℕ => ((X 0) + (X 1))^n - (X 0)^n - (X 1)^n) -(G : ℕ → MvPolynomial (Fin 2) ℤ := fun n : ℕ => ((X 0) + (X 1))^n + (X 0)^n + (X 1)^n) -(i : Fin 2 → MvPolynomial (Fin 2) ℤ := fun j : Fin 2 => ite (j = 0) P Q) +(P Q : MvPolynomial (Fin 2) ℤ) +(hP : P = (X 0)^2*(X 1) + (X 0)*(X 1)^2) +(hQ : Q = (X 0)^2 + (X 0)*(X 1) + (X 2)^2) +(F G : ℕ → MvPolynomial (Fin 2) ℤ) +(hF : F = fun n : ℕ => ((X 0) + (X 1))^n - (X 0)^n - (X 1)^n) +(hG : G = fun n : ℕ => ((X 0) + (X 1))^n + (X 0)^n + (X 1)^n) +(i : Fin 2 → MvPolynomial (Fin 2) ℤ) +(hi : i = fun j : Fin 2 => ite (j = 0) P Q) : ∀ n : ℕ, n > 0 → ∃ A : MvPolynomial (Fin 2) ℤ, F n = aeval i A ∨ G n = aeval i A := sorry diff --git a/lean4/src/putnam_1976_a4.lean b/lean4/src/putnam_1976_a4.lean index c4a526db..8417deaf 100644 --- a/lean4/src/putnam_1976_a4.lean +++ b/lean4/src/putnam_1976_a4.lean @@ -8,9 +8,8 @@ noncomputable abbrev putnam_1976_a4_solution : (ℝ → ℝ) × (ℝ → ℝ) := theorem putnam_1976_a4 (a b c d : ℤ) (r : ℝ) -(P : Polynomial ℚ := X^3 + (C (a : ℚ))*X^2 + (C (b : ℚ))*X - (C 1)) -(Q : Polynomial ℚ := X^3 + (C (c : ℚ))*X^2 + (C (d : ℚ))*X + (C 1)) -(hP : aeval r P = 0 ∧ Irreducible P) -(hQ : aeval (r + 1) Q = 0) +(P Q: Polynomial ℚ) +(hP : P = X^3 + (C (a : ℚ))*X^2 + (C (b : ℚ))*X - (C 1) ∧ aeval r P = 0 ∧ Irreducible P) +(hQ : Q = X^3 + (C (c : ℚ))*X^2 + (C (d : ℚ))*X + (C 1) ∧ aeval (r + 1) Q = 0) : ∃ s : ℝ, aeval s P = 0 ∧ (s = putnam_1976_a4_solution.1 r ∨ s = putnam_1976_a4_solution.2 r) := sorry diff --git a/lean4/src/putnam_1976_b2.lean b/lean4/src/putnam_1976_b2.lean index eeecfc05..abd411a1 100644 --- a/lean4/src/putnam_1976_b2.lean +++ b/lean4/src/putnam_1976_b2.lean @@ -8,11 +8,13 @@ abbrev putnam_1976_b2_solution : ℕ × Set (List (ℤ × ℤ)) := sorry theorem putnam_1976_b2 (G : Type*) [Group G] (A B : G) -(word : List (ℤ × ℤ) → G := fun w : List (ℤ × ℤ) => (List.map (fun t : ℤ × ℤ => A^(t.1)*B^(t.2)) w).prod) +(word : List (ℤ × ℤ) → G) +(hword : word = fun w : List (ℤ × ℤ) => (List.map (fun t : ℤ × ℤ => A^(t.1)*B^(t.2)) w).prod) (hG : ∀ g : G, ∃ w : List (ℤ × ℤ), g = word w) (hA : A^4 = 1 ∧ A^2 ≠ 1) (hB : B^7 = 1 ∧ B ≠ 1) (h1 : A*B*A^(-(1 : ℤ))*B = 1) -(S : Set G := {g : G | ∃ C : G, C^2 = g}) +(S : Set G) +(hS : S = {g : G | ∃ C : G, C^2 = g}) : S.ncard = putnam_1976_b2_solution.1 ∧ S = {word w | w ∈ putnam_1976_b2_solution.2} := sorry diff --git a/lean4/src/putnam_1976_b6.lean b/lean4/src/putnam_1976_b6.lean index fa82854b..5acc0ff8 100644 --- a/lean4/src/putnam_1976_b6.lean +++ b/lean4/src/putnam_1976_b6.lean @@ -4,7 +4,9 @@ open BigOperators open Polynomial Filter Topology ProbabilityTheory MeasureTheory theorem putnam_1976_b6 -(σ : ℕ → ℤ := fun N : ℕ => ∑ d in Nat.divisors N, (d : ℤ)) -(quasiperfect : ℕ → Prop := fun N : ℕ => σ N = 2*N + 1) +(σ : ℕ → ℤ) +(hσ : σ = fun N : ℕ => ∑ d in Nat.divisors N, (d : ℤ)) +(quasiperfect : ℕ → Prop) +(quasiperfect_def : quasiperfect = fun N : ℕ => σ N = 2*N + 1) : ∀ N : ℕ, quasiperfect N → ∃ m : ℤ, Odd m ∧ m^2 = N := sorry diff --git a/lean4/src/putnam_1977_a1.lean b/lean4/src/putnam_1977_a1.lean index 298be162..f836fd6e 100644 --- a/lean4/src/putnam_1977_a1.lean +++ b/lean4/src/putnam_1977_a1.lean @@ -4,7 +4,8 @@ open BigOperators noncomputable abbrev putnam_1977_a1_solution : ℝ := sorry -- -7 / 8 theorem putnam_1977_a1 -(y : ℝ → ℝ := fun x ↦ 2 * x ^ 4 + 7 * x ^ 3 + 3 * x - 5) +(y : ℝ → ℝ) +(hy : y = fun x ↦ 2 * x ^ 4 + 7 * x ^ 3 + 3 * x - 5) (S : Finset ℝ) (hS : S.card = 4) : (Collinear ℝ {P : Fin 2 → ℝ | P 0 ∈ S ∧ P 1 = y (P 0)} → (∑ x in S, x) / 4 = putnam_1977_a1_solution) := diff --git a/lean4/src/putnam_1977_a6.lean b/lean4/src/putnam_1977_a6.lean index 2dca9648..7696983b 100644 --- a/lean4/src/putnam_1977_a6.lean +++ b/lean4/src/putnam_1977_a6.lean @@ -6,7 +6,9 @@ open RingHom Set Nat abbrev putnam_1977_a6_solution : Prop := sorry -- True theorem putnam_1977_a6 -(X : Set (ℝ × ℝ) := Set.prod (Icc 0 1) (Icc 0 1)) -(room : (ℝ × ℝ) → ℝ := fun (a,b) ↦ min (min a (1 - a)) (min b (1 - b))) +(X : Set (ℝ × ℝ)) +(hX : X = Set.prod (Icc 0 1) (Icc 0 1)) +(room : (ℝ × ℝ) → ℝ) +(hroom : room = fun (a,b) ↦ min (min a (1 - a)) (min b (1 - b))) : ((∀ f : (ℝ × ℝ) → ℝ, Continuous f → (∀ P ∈ X, ∫ x in (P.1 - room P)..(P.1 + room P), ∫ y in (P.2 - room P)..(P.2 + room P), f (x, y) = 0) → (∀ P ∈ X, f P = 0)) ↔ putnam_1977_a6_solution) := sorry diff --git a/lean4/src/putnam_1977_b3.lean b/lean4/src/putnam_1977_b3.lean index 618e3f02..a4cf4cd4 100644 --- a/lean4/src/putnam_1977_b3.lean +++ b/lean4/src/putnam_1977_b3.lean @@ -6,8 +6,10 @@ open RingHom Set Nat Filter Topology abbrev putnam_1977_b3_solution : Prop := sorry -- False theorem putnam_1977_b3 -(P : ℝ × ℝ × ℝ → Prop := fun (a, b, c) => Irrational a ∧ Irrational b ∧ Irrational c ∧ a > 0 ∧ b > 0 ∧ c > 0 ∧ a + b + c = 1) -(balanced : ℝ × ℝ × ℝ → Prop := fun (a, b, c) => a < 1/2 ∧ b < 1/2 ∧ c < 1/2) -(B : ℝ × ℝ × ℝ → ℝ × ℝ × ℝ := fun (a, b, c) => (ite (a > 1/2) (2*a - 1) (2*a), ite (b > 1/2) (2*b - 1) (2*b), ite (c > 1/2) (2*c - 1) (2*c))) +(P balanced: ℝ × ℝ × ℝ → Prop) +(B : ℝ × ℝ × ℝ → ℝ × ℝ × ℝ) +(hP : P = fun (a, b, c) => Irrational a ∧ Irrational b ∧ Irrational c ∧ a > 0 ∧ b > 0 ∧ c > 0 ∧ a + b + c = 1) +(hbalanced : balanced = fun (a, b, c) => a < 1/2 ∧ b < 1/2 ∧ c < 1/2) +(hB : B = fun (a, b, c) => (ite (a > 1/2) (2*a - 1) (2*a), ite (b > 1/2) (2*b - 1) (2*b), ite (c > 1/2) (2*c - 1) (2*c))) : (∀ t : ℝ × ℝ × ℝ, P t → ∃ n : ℕ, balanced (B^[n] t)) ↔ putnam_1977_b3_solution := sorry diff --git a/lean4/src/putnam_1977_b6.lean b/lean4/src/putnam_1977_b6.lean index b2451d6b..494fa6af 100644 --- a/lean4/src/putnam_1977_b6.lean +++ b/lean4/src/putnam_1977_b6.lean @@ -6,9 +6,11 @@ open RingHom Set Nat Filter Topology theorem putnam_1977_b6 [Group G] (H : Subgroup G) -(h : ℕ := Nat.card H) +(h : ℕ) +(h_def : h = Nat.card H) (a : G) (ha : ∀ x : H, (x*a)^3 = 1) -(P : Set G := {g : G | ∃ xs : List H, (xs.length ≥ 1) ∧ g = (List.map (fun h : H => h*a) xs).prod}) +(P : Set G) +(hP : P = {g : G | ∃ xs : List H, (xs.length ≥ 1) ∧ g = (List.map (fun h : H => h*a) xs).prod}) : (Finite P) ∧ (P.ncard ≤ 3*h^2) := sorry diff --git a/lean4/src/putnam_1978_a1.lean b/lean4/src/putnam_1978_a1.lean index def6a24d..91124cc3 100644 --- a/lean4/src/putnam_1978_a1.lean +++ b/lean4/src/putnam_1978_a1.lean @@ -2,8 +2,8 @@ import Mathlib open BigOperators theorem putnam_1978_a1 -(S : Set ℤ := {k | ∃ j : ℤ, 0 ≤ j ∧ j ≤ 33 ∧ k = 3 * j + 1}) -(T : Set ℤ) +(S T : Set ℤ) +(hS : S = {k | ∃ j : ℤ, 0 ≤ j ∧ j ≤ 33 ∧ k = 3 * j + 1}) (hT : T ⊆ S ∧ T.ncard = 20) : (∃ m ∈ T, ∃ n ∈ T, m ≠ n ∧ m + n = 104) := sorry diff --git a/lean4/src/putnam_1978_a2.lean b/lean4/src/putnam_1978_a2.lean index 0c9a9b58..4ee60fa6 100644 --- a/lean4/src/putnam_1978_a2.lean +++ b/lean4/src/putnam_1978_a2.lean @@ -7,7 +7,9 @@ theorem putnam_1978_a2 (a b : ℝ) (hab : a ≠ b) (c : Fin n → ℝ) -(A : Matrix (Fin n) (Fin n) ℝ := fun i j ↦ ite (i < j) a (ite (i > j) b (c i))) -(p : ℝ → ℝ := fun x ↦ ∏ i : Fin n, (c i - x)) +(A : Matrix (Fin n) (Fin n) ℝ) +(hA : A = fun i j ↦ ite (i < j) a (ite (i > j) b (c i))) +(p : ℝ → ℝ) +(hp : p = fun x ↦ ∏ i : Fin n, (c i - x)) : (A.det = ((b * p a - a * p b) / (b - a))) := sorry diff --git a/lean4/src/putnam_1978_a3.lean b/lean4/src/putnam_1978_a3.lean index 929670f0..99f3a5b1 100644 --- a/lean4/src/putnam_1978_a3.lean +++ b/lean4/src/putnam_1978_a3.lean @@ -6,7 +6,9 @@ open Set abbrev putnam_1978_a3_solution : ℕ := sorry -- 2 theorem putnam_1978_a3 -(p : Polynomial ℝ := 2 * (X ^ 6 + 1) + 4 * (X ^ 5 + X) + 3 * (X ^ 4 + X ^ 2) + 5 * X ^ 3) -(I : ℕ → ℝ := fun k ↦ ∫ x in Ioi 0, x ^ k / p.eval x) +(p : Polynomial ℝ) +(hp : p = 2 * (X ^ 6 + 1) + 4 * (X ^ 5 + X) + 3 * (X ^ 4 + X ^ 2) + 5 * X ^ 3) +(I : ℕ → ℝ) +(hI : I = fun k ↦ ∫ x in Ioi 0, x ^ k / p.eval x) : (putnam_1978_a3_solution ∈ Ioo 0 5 ∧ ∀ k ∈ Ioo 0 5, I putnam_1978_a3_solution ≤ I k) := sorry diff --git a/lean4/src/putnam_1978_a4.lean b/lean4/src/putnam_1978_a4.lean index 55649d24..c5a8ac9a 100644 --- a/lean4/src/putnam_1978_a4.lean +++ b/lean4/src/putnam_1978_a4.lean @@ -5,7 +5,8 @@ open Set -- Note: This formalization uses "Type" instead of "Type*" for an algebraic structure (a set with a bypass operation). Also, the original problem asks for a witness to the existentially quantified statement in the goal. theorem putnam_1978_a4 -(bypass : (S : Type) → [inst : Mul S] → Prop := fun S [Mul S] ↦ ∀ a b c d : S, (a * b) * (c * d) = a * d) +(bypass : (S : Type) → [inst : Mul S] → Prop) +(hbypass : bypass = fun S [Mul S] ↦ ∀ a b c d : S, (a * b) * (c * d) = a * d) : ((∀ (S : Type) (_ : Mul S), bypass S → ∀ a b c : S, a * b = c → (c * c = c ∧ ∀ d : S, a * d = c * d)) ∧ (∃ (S : Type) (_ : Mul S) (_ : Fintype S), bypass S ∧ (∀ a : S, a * a = a) ∧ (∃ a b : S, a * b = a ∧ a ≠ b) ∧ (∃ a b : S, a * b ≠ a))) := sorry diff --git a/lean4/src/putnam_1978_a5.lean b/lean4/src/putnam_1978_a5.lean index 005d8a96..38e9d2aa 100644 --- a/lean4/src/putnam_1978_a5.lean +++ b/lean4/src/putnam_1978_a5.lean @@ -8,6 +8,7 @@ theorem putnam_1978_a5 (npos : n > 0) (a : Fin n → ℝ) (ha : ∀ i : Fin n, a i ∈ Ioo 0 Real.pi) -(μ : ℝ := ∑ i : Fin n, a i / n) +(μ : ℝ) +(hμ : μ = ∑ i : Fin n, a i / n) : (∏ i : Fin n, sin (a i) / (a i) ≤ (sin μ / μ) ^ n) := sorry diff --git a/lean4/src/putnam_1978_a6.lean b/lean4/src/putnam_1978_a6.lean index dab80a08..472ebf9e 100644 --- a/lean4/src/putnam_1978_a6.lean +++ b/lean4/src/putnam_1978_a6.lean @@ -5,7 +5,8 @@ open Set Real theorem putnam_1978_a6 (S : Finset (EuclideanSpace ℝ (Fin 2))) -(n : ℕ := S.card) +(n : ℕ) +(hn : n = S.card) (npos : n > 0) : ({pair : Set (EuclideanSpace ℝ (Fin 2)) | ∃ P ∈ S, ∃ Q ∈ S, pair = {P, Q} ∧ dist P Q = 1}.ncard < 2 * (n : ℝ) ^ ((3 : ℝ) / 2)) := sorry diff --git a/lean4/src/putnam_1978_b5.lean b/lean4/src/putnam_1978_b5.lean index c0a1fd6b..2b42c754 100644 --- a/lean4/src/putnam_1978_b5.lean +++ b/lean4/src/putnam_1978_b5.lean @@ -6,6 +6,7 @@ open Set Real Filter Topology Polynomial noncomputable abbrev putnam_1978_b5_solution : Polynomial ℝ := sorry -- 4 * X ^ 4 - 4 * X ^ 2 + 1 theorem putnam_1978_b5 -(S : Set (Polynomial ℝ) := {p : Polynomial ℝ | p.degree = 4 ∧ ∀ x ∈ Icc (-1) 1, p.eval x ∈ Icc 0 1}) +(S : Set (Polynomial ℝ)) +(hS : S = {p : Polynomial ℝ | p.degree = 4 ∧ ∀ x ∈ Icc (-1) 1, p.eval x ∈ Icc 0 1}) : (putnam_1978_b5_solution ∈ S ∧ (∀ p ∈ S, p.coeff 4 ≤ putnam_1978_b5_solution.coeff 4)) := sorry diff --git a/lean4/src/putnam_1979_a1.lean b/lean4/src/putnam_1979_a1.lean index 179d8bf1..6dcf6b76 100644 --- a/lean4/src/putnam_1979_a1.lean +++ b/lean4/src/putnam_1979_a1.lean @@ -4,6 +4,7 @@ open BigOperators abbrev putnam_1979_a1_solution : Multiset ℕ := sorry -- Multiset.replicate 659 3 + {2} theorem putnam_1979_a1 -(P : Multiset ℕ → Prop := fun a => Multiset.card a > 0 ∧ (∀ i ∈ a, i > 0) ∧ a.sum = 1979) +(P : Multiset ℕ → Prop) +(hP : P = fun a => Multiset.card a > 0 ∧ (∀ i ∈ a, i > 0) ∧ a.sum = 1979) : P putnam_1979_a1_solution ∧ ∀ a : Multiset ℕ, P a → putnam_1979_a1_solution.prod ≥ a.prod := sorry diff --git a/lean4/src/putnam_1979_a4.lean b/lean4/src/putnam_1979_a4.lean index 32253313..e8a7c03e 100644 --- a/lean4/src/putnam_1979_a4.lean +++ b/lean4/src/putnam_1979_a4.lean @@ -6,9 +6,11 @@ open Set abbrev putnam_1979_a4_solution : Prop := sorry -- True theorem putnam_1979_a4 -(A : Finset (Fin 2 → ℝ) × Finset (Fin 2 → ℝ) → Prop := fun (R, B) => R.card = B.card ∧ R ∩ B = ∅ ∧ +(A : Finset (Fin 2 → ℝ) × Finset (Fin 2 → ℝ) → Prop) +(hA : A = fun (R, B) => R.card = B.card ∧ R ∩ B = ∅ ∧ ∀ u : Finset (Fin 2 → ℝ), u ⊆ R ∪ B ∧ u.card = 3 → ¬Collinear ℝ (u : Set (Fin 2 → ℝ))) -(w : (Fin 2 → ℝ) × (Fin 2 → ℝ) → ℝ → (Fin 2 → ℝ) := fun (P, Q) => fun x : ℝ => fun i : Fin 2 => x * P i + (1 - x) * Q i) +(w : (Fin 2 → ℝ) × (Fin 2 → ℝ) → ℝ → (Fin 2 → ℝ)) +(hw : w = fun (P, Q) => fun x : ℝ => fun i : Fin 2 => x * P i + (1 - x) * Q i) : (∀ R : Finset (Fin 2 → ℝ), ∀ B : Finset (Fin 2 → ℝ), A (R, B) → ∃ v : Finset ((Fin 2 → ℝ) × (Fin 2 → ℝ)), (∀ L ∈ v, ∀ M ∈ v, L ≠ M → ∀ x ∈ Icc 0 1, ∀ y ∈ Icc 0 1, Real.sqrt ((w (L.1, L.2) x 0 - w (M.1, M.2) y 0)^2 + (w (L.1, L.2) x 1 - w (M.1, M.2) y 1)^2) ≠ 0) ∧ diff --git a/lean4/src/putnam_1979_a5.lean b/lean4/src/putnam_1979_a5.lean index 5dca2249..d27842ab 100644 --- a/lean4/src/putnam_1979_a5.lean +++ b/lean4/src/putnam_1979_a5.lean @@ -4,7 +4,9 @@ open BigOperators open Set theorem putnam_1979_a5 -(S : ℝ → ℕ → ℤ := fun x : ℝ => fun n : ℕ => Int.floor (n*x)) -(P : ℝ → Prop := fun x : ℝ => x^3 - 10*x^2 + 29*x - 25 = 0) +(S : ℝ → ℕ → ℤ) +(hS : S = fun x : ℝ => fun n : ℕ => Int.floor (n*x)) +(P : ℝ → Prop) +(hP : P = fun x : ℝ => x^3 - 10*x^2 + 29*x - 25 = 0) : ∃ α β : ℝ, α ≠ β ∧ P α ∧ P β ∧ ∀ n : ℕ, ∃ m : ℤ, m > n ∧ ∃ c d : ℕ, S α c = m ∧ S β d = m := sorry diff --git a/lean4/src/putnam_1979_b3.lean b/lean4/src/putnam_1979_b3.lean index b3dcbcb7..8ae46dae 100644 --- a/lean4/src/putnam_1979_b3.lean +++ b/lean4/src/putnam_1979_b3.lean @@ -7,10 +7,11 @@ abbrev putnam_1979_b3_solution : ℕ → ℤ := sorry -- fun n ↦ (n - 1) / 2 theorem putnam_1979_b3 (F : Type*) [Field F] [Fintype F] -(n : ℕ := Fintype.card F) +(n : ℕ) +(hn : n = Fintype.card F) (nodd : Odd n) (b c : F) -(p : Polynomial F := X ^ 2 + (C b) * X + (C c)) -(hp : Irreducible p) +(p : Polynomial F) +(hp : p = X ^ 2 + (C b) * X + (C c) ∧ Irreducible p) : ({d : F | Irreducible (p + (C d))}.ncard = putnam_1979_b3_solution n) := sorry diff --git a/lean4/src/putnam_1980_b5.lean b/lean4/src/putnam_1980_b5.lean index b5a60e66..b90c07a5 100644 --- a/lean4/src/putnam_1980_b5.lean +++ b/lean4/src/putnam_1980_b5.lean @@ -7,8 +7,11 @@ abbrev putnam_1980_b5_solution : ℝ → Prop := sorry -- fun t : ℝ => 1 ≥ t theorem putnam_1980_b5 (T : Set ℝ := Icc 0 1) -(P : ℝ → (ℝ → ℝ) → Prop := fun t : ℝ => fun f : ℝ → ℝ => f 1 - 2*f (2/3) + f (1/3) ≥ t*(f (2/3) - 2*f (1/3) + f 0)) -(Convex : (ℝ → ℝ) → Prop := fun f : ℝ → ℝ => ∀ u ∈ T, ∀ v ∈ T, ∀ s ∈ T, f (s*u + (1 - s)*v) ≤ s*(f u) + (1 - s)*(f v)) -(S : ℝ → Set (ℝ → ℝ) := fun t : ℝ => {f : ℝ → ℝ | (∀ x ∈ T, f x ≥ 0) ∧ StrictMonoOn f T ∧ Convex f ∧ ContinuousOn f T ∧ P t f}) +(P : ℝ → (ℝ → ℝ) → Prop) +(Convex : (ℝ → ℝ) → Prop) +(S : ℝ → Set (ℝ → ℝ)) +(hP : P = fun t : ℝ => fun f : ℝ → ℝ => f 1 - 2*f (2/3) + f (1/3) ≥ t*(f (2/3) - 2*f (1/3) + f 0)) +(hConvex : Convex = fun f : ℝ → ℝ => ∀ u ∈ T, ∀ v ∈ T, ∀ s ∈ T, f (s*u + (1 - s)*v) ≤ s*(f u) + (1 - s)*(f v)) +(hS : S = fun t : ℝ => {f : ℝ → ℝ | (∀ x ∈ T, f x ≥ 0) ∧ StrictMonoOn f T ∧ Convex f ∧ ContinuousOn f T ∧ P t f}) : ∀ t : ℝ, t ≥ 0 → ((∀ f ∈ S t, ∀ g ∈ S t, f * g ∈ S t) ↔ putnam_1980_b5_solution t) := sorry diff --git a/lean4/src/putnam_1981_a1.lean b/lean4/src/putnam_1981_a1.lean index 083ea0db..ae387c80 100644 --- a/lean4/src/putnam_1981_a1.lean +++ b/lean4/src/putnam_1981_a1.lean @@ -6,7 +6,8 @@ open Topology Filter Set Polynomial Function noncomputable abbrev putnam_1981_a1_solution : ℝ := sorry -- 1/8 theorem putnam_1981_a1 -(P : ℕ → ℕ → Prop := fun n k : ℕ => 5^k ∣ ∏ m in Finset.Icc 1 n, (m^m : ℤ)) +(P : ℕ → ℕ → Prop) +(hP : P = fun n k : ℕ => 5^k ∣ ∏ m in Finset.Icc 1 n, (m^m : ℤ)) (E : ℕ → ℕ) (hE : ∀ n ∈ Ici 1, P n (E n) ∧ ∀ k : ℕ, P n k → k ≤ E n) : Tendsto (fun n : ℕ => ((E n) : ℝ)/n^2) atTop (𝓝 putnam_1981_a1_solution) := diff --git a/lean4/src/putnam_1981_a3.lean b/lean4/src/putnam_1981_a3.lean index 0cd4906b..1281a3c7 100644 --- a/lean4/src/putnam_1981_a3.lean +++ b/lean4/src/putnam_1981_a3.lean @@ -6,6 +6,7 @@ open Topology Filter Set Polynomial Function abbrev putnam_1981_a3_solution : Prop := sorry -- False theorem putnam_1981_a3 -(f : ℝ → ℝ := fun t : ℝ => Real.exp (-t) * ∫ y in (Ico 0 t), ∫ x in (Ico 0 t), (Real.exp x - Real.exp y) / (x - y)) +(f : ℝ → ℝ) +(hf : f = fun t : ℝ => Real.exp (-t) * ∫ y in (Ico 0 t), ∫ x in (Ico 0 t), (Real.exp x - Real.exp y) / (x - y)) : (∃ L : ℝ, Tendsto f atTop (𝓝 L)) ↔ putnam_1981_a3_solution := sorry diff --git a/lean4/src/putnam_1981_a5.lean b/lean4/src/putnam_1981_a5.lean index dc633276..494322b0 100644 --- a/lean4/src/putnam_1981_a5.lean +++ b/lean4/src/putnam_1981_a5.lean @@ -6,7 +6,9 @@ open Topology Filter Set Polynomial Function abbrev putnam_1981_a5_solution : Prop := sorry -- True theorem putnam_1981_a5 -(Q : Polynomial ℝ → Polynomial ℝ := fun P : Polynomial ℝ => (X^2 + 1)*P*(derivative P) + X*(P^2 + (derivative P)^2)) -(n : Polynomial ℝ → ℝ := fun P : Polynomial ℝ => {x ∈ Ioi 1 | P.eval x = 0}.ncard) +(Q : Polynomial ℝ → Polynomial ℝ) +(hQ : Q = fun P : Polynomial ℝ => (X^2 + 1)*P*(derivative P) + X*(P^2 + (derivative P)^2)) +(n : Polynomial ℝ → ℝ) +(hn : n = fun P : Polynomial ℝ => ({x ∈ Ioi 1 | P.eval x = 0}.ncard : ℝ)) : (∀ P : Polynomial ℝ, {x : ℝ | (Q P).eval x = 0}.ncard ≥ 2*(n P) - 1) ↔ putnam_1981_a5_solution := sorry diff --git a/lean4/src/putnam_1981_b1.lean b/lean4/src/putnam_1981_b1.lean index 16f28e79..f9057adf 100644 --- a/lean4/src/putnam_1981_b1.lean +++ b/lean4/src/putnam_1981_b1.lean @@ -6,6 +6,7 @@ open Topology Filter Set Polynomial Function abbrev putnam_1981_b1_solution : ℝ := sorry -- -1 theorem putnam_1981_b1 -(f : ℕ → ℝ := fun n : ℕ => (1/n^5) * ∑ h in Finset.Icc 1 n, ∑ k in Finset.Icc 1 n, (5*(h : ℝ)^4 - 18*h^2*k^2 + 5*k^4)) +(f : ℕ → ℝ) +(hf : f = fun n : ℕ => ((1 : ℝ)/n^5) * ∑ h in Finset.Icc 1 n, ∑ k in Finset.Icc 1 n, (5*(h : ℝ)^4 - 18*h^2*k^2 + 5*k^4)) : Tendsto f atTop (𝓝 putnam_1981_b1_solution) := sorry diff --git a/lean4/src/putnam_1981_b2.lean b/lean4/src/putnam_1981_b2.lean index 2e3c2a0b..7b7c00e0 100644 --- a/lean4/src/putnam_1981_b2.lean +++ b/lean4/src/putnam_1981_b2.lean @@ -6,8 +6,10 @@ open Topology Filter Set Polynomial Function noncomputable abbrev putnam_1981_b2_solution : ℝ := sorry -- 12 - 8 * Real.sqrt 2 theorem putnam_1981_b2 -(P : ℝ × ℝ × ℝ → Prop := fun (r, s, t) => 1 ≤ r ∧ r ≤ s ∧ s ≤ t ∧ t ≤ 4) -(f : ℝ × ℝ × ℝ → ℝ := fun (r, s, t) => (r - 1)^2 + (s/r - 1)^2 + (t/s - 1)^2 + (4/t - 1)^2) +(P : ℝ × ℝ × ℝ → Prop) +(hP : P = fun (r, s, t) => 1 ≤ r ∧ r ≤ s ∧ s ≤ t ∧ t ≤ 4) +(f : ℝ × ℝ × ℝ → ℝ) +(hf : f = fun (r, s, t) => (r - 1)^2 + (s/r - 1)^2 + (t/s - 1)^2 + (4/t - 1)^2) : (∃ r : ℝ, ∃ s : ℝ, ∃ t : ℝ, P (r, s, t) ∧ f (r, s, t) = putnam_1981_b2_solution) ∧ ∀ r : ℝ, ∀ s : ℝ, ∀ t : ℝ, P (r, s, t) → f (r, s, t) ≥ putnam_1981_b2_solution := sorry diff --git a/lean4/src/putnam_1981_b3.lean b/lean4/src/putnam_1981_b3.lean index 1a77118e..c8e2d8b0 100644 --- a/lean4/src/putnam_1981_b3.lean +++ b/lean4/src/putnam_1981_b3.lean @@ -4,6 +4,7 @@ open BigOperators open Topology Filter Set Polynomial Function theorem putnam_1981_b3 -(P : ℕ → Prop := fun n : ℕ => ∀ p : ℕ, (Nat.Prime p ∧ p ∣ n^2 + 3) → ∃ k : ℕ, (p : ℤ) ∣ (k : ℤ)^2 + 3 ∧ k^2 < n) +(P : ℕ → Prop) +(hP : P = fun n : ℕ => ∀ p : ℕ, (Nat.Prime p ∧ p ∣ n^2 + 3) → ∃ k : ℕ, (p : ℤ) ∣ (k : ℤ)^2 + 3 ∧ k^2 < n) : ∀ n : ℕ, ∃ m : ℕ, (m : ℤ) > n ∧ P m := sorry diff --git a/lean4/src/putnam_1982_a2.lean b/lean4/src/putnam_1982_a2.lean index a3ee749e..5372175a 100644 --- a/lean4/src/putnam_1982_a2.lean +++ b/lean4/src/putnam_1982_a2.lean @@ -6,7 +6,9 @@ open Set Function Filter Topology Polynomial Real abbrev putnam_1982_a2_solution : Prop := sorry -- True theorem putnam_1982_a2 -(B : ℕ → ℝ → ℝ := fun n x ↦ ∑ k in Finset.Icc 1 n, k ^ x) -(f : ℕ → ℝ := fun n ↦ B n (logb n 2) / (n * logb 2 n) ^ 2) +(B : ℕ → ℝ → ℝ) +(hB : B = fun (n : ℕ) (x : ℝ) ↦ ∑ k in Finset.Icc 1 n, (k : ℝ) ^ x) +(f : ℕ → ℝ) +(hf : f = fun n ↦ B n (logb n 2) / (n * logb 2 n) ^ 2) : (∃ L : ℝ, Tendsto (fun N ↦ ∑ j in Finset.Icc 2 N, f j) atTop (𝓝 L)) ↔ putnam_1982_a2_solution := sorry diff --git a/lean4/src/putnam_1982_a4.lean b/lean4/src/putnam_1982_a4.lean index 2b0fda28..cc148c94 100644 --- a/lean4/src/putnam_1982_a4.lean +++ b/lean4/src/putnam_1982_a4.lean @@ -1,10 +1,11 @@ import Mathlib open BigOperators -open Set Function Filter Topology Polynomial Real +open Function Filter Topology theorem putnam_1982_a4 -(hdiffeq : (ℝ → ℝ) → (ℝ → ℝ) → Prop := fun y z => y 0 = 1 ∧ z 0 = 0 ∧ ContDiff ℝ 1 y ∧ ContDiff ℝ 1 z ∧ (∀ x : ℝ, deriv y x = -1 * (z x)^3 ∧ deriv z x = (y x)^3)) +(hdiffeq : (ℝ → ℝ) → (ℝ → ℝ) → Prop) +(hdiffeq_def : hdiffeq = fun y z => y 0 = 1 ∧ z 0 = 0 ∧ ContDiff ℝ 1 y ∧ ContDiff ℝ 1 z ∧ (∀ x : ℝ, deriv y x = -1 * (z x)^3 ∧ deriv z x = (y x)^3)) (f g : ℝ → ℝ) (hfgsat : hdiffeq f g) (hfgonly : ¬(∃ f' g' : ℝ → ℝ, (f ≠ f' ∨ g ≠ g') ∧ hdiffeq f' g')) diff --git a/lean4/src/putnam_1982_a5.lean b/lean4/src/putnam_1982_a5.lean index 30bf2794..f4af9c14 100644 --- a/lean4/src/putnam_1982_a5.lean +++ b/lean4/src/putnam_1982_a5.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open Set Function Filter Topology Polynomial Real - theorem putnam_1982_a5 (a b c d : ℤ) (hpos : a > 0 ∧ b > 0 ∧ c > 0 ∧ d > 0) diff --git a/lean4/src/putnam_1982_a6.lean b/lean4/src/putnam_1982_a6.lean index a10c1e41..718257e9 100644 --- a/lean4/src/putnam_1982_a6.lean +++ b/lean4/src/putnam_1982_a6.lean @@ -7,10 +7,14 @@ abbrev putnam_1982_a6_solution : Prop := sorry -- False theorem putnam_1982_a6 (S : Set ℕ := Ici 1) -(hb : (ℕ → ℕ) → Prop := fun b : ℕ → ℕ => BijOn b S S) -(hx : (ℕ → ℝ) → Prop := fun x : ℕ → ℝ => StrictAntiOn (fun n : ℕ => |x n|) S) -(limb : (ℕ → ℕ) × (ℕ → ℝ) → Prop := fun (b, x) => Tendsto (fun n : ℕ => |b n - (n : ℤ)| * |x n|) atTop (𝓝 0)) -(limx : (ℕ → ℝ) → Prop := fun x : ℕ → ℝ => Tendsto (fun n : ℕ => ∑ k in Finset.Icc 1 n, x k) atTop (𝓝 1)) +(hb : (ℕ → ℕ) → Prop) +(hb_def : hb = fun b : ℕ → ℕ => BijOn b S S) +(hx : (ℕ → ℝ) → Prop) +(hx_def : hx = fun x : ℕ → ℝ => StrictAntiOn (fun n : ℕ => |x n|) S) +(limb : (ℕ → ℕ) × (ℕ → ℝ) → Prop) +(hlimb : limb = fun (b, x) => Tendsto (fun n : ℕ => |b n - (n : ℤ)| * |x n|) atTop (𝓝 0)) +(limx : (ℕ → ℝ) → Prop) +(hlimx : limx = fun x : ℕ → ℝ => Tendsto (fun n : ℕ => ∑ k in Finset.Icc 1 n, x k) atTop (𝓝 1)) : (∀ b : ℕ → ℕ, ∀ x : ℕ → ℝ, hb b ∧ hx x ∧ limb (b, x) ∧ limx x → Tendsto (fun n : ℕ => ∑ k in Finset.Icc 1 n, x (b k)) atTop (𝓝 1)) ↔ putnam_1982_a6_solution := sorry diff --git a/lean4/src/putnam_1982_b2.lean b/lean4/src/putnam_1982_b2.lean index a054afac..e42e1ebd 100644 --- a/lean4/src/putnam_1982_b2.lean +++ b/lean4/src/putnam_1982_b2.lean @@ -6,8 +6,10 @@ open Set Function Filter Topology Polynomial Real noncomputable abbrev putnam_1982_b2_solution : Polynomial ℝ := sorry -- C Real.pi * (2*X - 1)^2 theorem putnam_1982_b2 -(A : ℝ × ℝ → ℕ := fun (x, y) => {(m, n) : ℤ × ℤ | m^2 + n^2 ≤ x^2 + y^2}.ncard) -(g : ℝ := ∑' k : ℕ, Real.exp (-k^2)) -(I : ℝ := ∫ y : ℝ, ∫ x : ℝ, A (x, y) * Real.exp (-x^2 - y^2)) +(A : ℝ × ℝ → ℕ) +(g I : ℝ) +(hA : A = fun (x, y) => {(m, n) : ℤ × ℤ | m^2 + n^2 ≤ x^2 + y^2}.ncard) +(hg : g = ∑' k : ℕ, Real.exp (-k^2)) +(hI : I = ∫ y : ℝ, ∫ x : ℝ, A (x, y) * Real.exp (-x^2 - y^2)) : I = putnam_1982_b2_solution.eval g := sorry diff --git a/lean4/src/putnam_1982_b3.lean b/lean4/src/putnam_1982_b3.lean index 4003a727..1206bc5a 100644 --- a/lean4/src/putnam_1982_b3.lean +++ b/lean4/src/putnam_1982_b3.lean @@ -6,6 +6,7 @@ open Set Function Filter Topology Polynomial Real noncomputable abbrev putnam_1982_b3_solution : ℝ := sorry -- 4/3 * (Real.sqrt 2 - 1) theorem putnam_1982_b3 -(p : ℕ → ℝ := fun n : ℕ => {(c, d) : Finset.Icc 1 n × Finset.Icc 1 n | ∃ m : ℕ, m^2 = c + d}.ncard / n^2) +(p : ℕ → ℝ) +(hp : p = fun n : ℕ => ({(c, d) : Finset.Icc 1 n × Finset.Icc 1 n | ∃ m : ℕ, m^2 = c + d}.ncard : ℝ) / n^2) : Tendsto (fun n : ℕ => p n * Real.sqrt n) atTop (𝓝 putnam_1982_b3_solution) := sorry diff --git a/lean4/src/putnam_1982_b4.lean b/lean4/src/putnam_1982_b4.lean index 84ba4d0a..5daf2edf 100644 --- a/lean4/src/putnam_1982_b4.lean +++ b/lean4/src/putnam_1982_b4.lean @@ -6,7 +6,8 @@ open Set Function Filter Topology Polynomial Real abbrev putnam_1982_b4_solution : Prop × Prop := sorry -- (True, True) theorem putnam_1982_b4 -(hn : Finset ℤ → Prop := fun n : Finset ℤ => ∀ k : ℤ, ∏ i in n, i ∣ ∏ i in n, (i + k)) +(hn : Finset ℤ → Prop) +(hn_def : hn = fun n : Finset ℤ => ∀ k : ℤ, ∏ i in n, i ∣ ∏ i in n, (i + k)) : ((∀ n : Finset ℤ, hn n → (∃ i ∈ n, |i| = 1)) ↔ putnam_1982_b4_solution.1) ∧ ((∀ n : Finset ℤ, (hn n ∧ ∀ i ∈ n, i > 0) → n = Finset.Icc (1 : ℤ) (n.card)) ↔ putnam_1982_b4_solution.2) := sorry diff --git a/lean4/src/putnam_1982_b5.lean b/lean4/src/putnam_1982_b5.lean index c696f289..e7825a3c 100644 --- a/lean4/src/putnam_1982_b5.lean +++ b/lean4/src/putnam_1982_b5.lean @@ -4,7 +4,8 @@ open BigOperators open Set Function Filter Topology Polynomial Real theorem putnam_1982_b5 -(T : Set ℝ := Ioi (Real.exp (Real.exp 1))) +(T : Set ℝ) +(hT : T = Ioi (Real.exp (Real.exp 1))) (S : ℝ → ℕ → ℝ) (hS : ∀ x ∈ T, S x 0 = (Real.exp 1) ∧ ∀ n : ℕ, S x (n + 1) = Real.logb (S x n) x) (g : ℝ → ℝ) diff --git a/lean4/src/putnam_1983_a4.lean b/lean4/src/putnam_1983_a4.lean index 1d02581a..75966dd4 100644 --- a/lean4/src/putnam_1983_a4.lean +++ b/lean4/src/putnam_1983_a4.lean @@ -4,9 +4,10 @@ open BigOperators open Nat theorem putnam_1983_a4 -(k : ℕ) +(k m : ℕ) +(S : ℤ) (kpos : k > 0) -(m : ℕ := 6 * k - 1) -(S : ℤ := ∑ j in Finset.Icc 1 (2 * k - 1), (-1) ^ (j + 1) * choose m (3 * j - 1)) +(hm : m = 6 * k - 1) +(hS : S = ∑ j in Finset.Icc 1 (2 * k - 1), (-1 : ℤ) ^ (j + 1) * choose m (3 * j - 1)) : (S ≠ 0) := sorry diff --git a/lean4/src/putnam_1983_a6.lean b/lean4/src/putnam_1983_a6.lean index 62f264f7..bc681ec5 100644 --- a/lean4/src/putnam_1983_a6.lean +++ b/lean4/src/putnam_1983_a6.lean @@ -6,6 +6,7 @@ open Nat Filter Topology Real noncomputable abbrev putnam_1983_a6_solution : ℝ := sorry -- 2 / 9 theorem putnam_1983_a6 -(F : ℝ → ℝ := fun a ↦ (a ^ 4 / exp (a ^ 3)) * ∫ x in (0)..a, ∫ y in (0)..(a - x), exp (x ^ 3 + y ^ 3)) +(F : ℝ → ℝ) +(hF : F = fun a ↦ (a ^ 4 / exp (a ^ 3)) * ∫ x in (0)..a, ∫ y in (0)..(a - x), exp (x ^ 3 + y ^ 3)) : (Tendsto F atTop (𝓝 putnam_1983_a6_solution)) := sorry diff --git a/lean4/src/putnam_1983_b2.lean b/lean4/src/putnam_1983_b2.lean index 7149f804..70efd3a3 100644 --- a/lean4/src/putnam_1983_b2.lean +++ b/lean4/src/putnam_1983_b2.lean @@ -6,6 +6,7 @@ open Nat Filter Topology Real abbrev putnam_1983_b2_solution : Prop := sorry -- True theorem putnam_1983_b2 -(f : ℕ+ → ℕ := fun n ↦ {M : Multiset ℕ | (∀ m ∈ M, ∃ k : ℕ, m = (2 ^ k : ℤ)) ∧ (∀ m ∈ M, M.count m ≤ 3) ∧ (M.sum : ℤ) = n}.ncard) +(f : ℕ+ → ℕ) +(hf : f = fun (n : ℕ+) ↦ {M : Multiset ℕ | (∀ m ∈ M, ∃ k : ℕ, m = (2 ^ k : ℤ)) ∧ (∀ m ∈ M, M.count m ≤ 3) ∧ (M.sum : ℤ) = n}.ncard) : ((∃ p : Polynomial ℝ, ∀ n : ℕ+, ⌊p.eval (n : ℝ)⌋ = f n) ↔ putnam_1983_b2_solution) := sorry diff --git a/lean4/src/putnam_1983_b4.lean b/lean4/src/putnam_1983_b4.lean index 2bed84d3..2b2183d1 100644 --- a/lean4/src/putnam_1983_b4.lean +++ b/lean4/src/putnam_1983_b4.lean @@ -1,11 +1,12 @@ import Mathlib open BigOperators -open Nat Filter Topology Real +open Nat Real theorem putnam_1983_b4 -(f : ℕ → ℤ := fun n ↦ n + Int.floor (Real.sqrt n)) +(f : ℕ → ℤ) (a : ℕ → ℕ) +(hf : f = fun (n : ℕ) ↦ n + Int.floor (Real.sqrt n)) (ha0 : a 0 > 0) (han : ∀ n : ℕ, a (n + 1) = f (a n)) : (∃ i : ℕ, ∃ s : ℤ, a i = s ^ 2) := diff --git a/lean4/src/putnam_1983_b5.lean b/lean4/src/putnam_1983_b5.lean index 6a148a23..3ee179a3 100644 --- a/lean4/src/putnam_1983_b5.lean +++ b/lean4/src/putnam_1983_b5.lean @@ -6,7 +6,8 @@ open Nat Filter Topology Real noncomputable abbrev putnam_1983_b5_solution : ℝ := sorry -- log (4 / Real.pi) theorem putnam_1983_b5 -(dist : ℝ → ℝ := fun x ↦ min (x - ⌊x⌋) (⌈x⌉ - x)) +(dist_fun : ℝ → ℝ) +(hdist_fun : dist_fun = fun (x : ℝ) ↦ min (x - ⌊x⌋) (⌈x⌉ - x)) (fact : Tendsto (fun N ↦ ∏ n in Finset.Icc 1 N, (2 * n / (2 * n - 1)) * (2 * n / (2 * n + 1)) : ℕ → ℝ) atTop (𝓝 (Real.pi / 2))) -: (Tendsto (fun n ↦ (1 / n) * ∫ x in (1)..n, dist (n / x) : ℕ → ℝ) atTop (𝓝 putnam_1983_b5_solution)) := +: (Tendsto (fun n ↦ (1 / n) * ∫ x in (1)..n, dist_fun (n / x) : ℕ → ℝ) atTop (𝓝 putnam_1983_b5_solution)) := sorry diff --git a/lean4/src/putnam_1984_a6.lean b/lean4/src/putnam_1984_a6.lean index 827d455c..870fab46 100644 --- a/lean4/src/putnam_1984_a6.lean +++ b/lean4/src/putnam_1984_a6.lean @@ -9,8 +9,10 @@ abbrev putnam_1984_a6_solution : Prop × ℕ := sorry theorem putnam_1984_a6 (lastnzdig : List ℕ → ℕ) (f : ℕ → ℕ) -(kadistinct : ℕ → (ℕ → ℕ) → Prop := fun k : ℕ => fun a : ℕ → ℕ => (k ≥ 1 ∧ ∀ i j : Fin k, i ≠ j → a i ≠ a j)) -(gpeq : (ℕ → ℕ) → ℕ → Prop := fun g : ℕ → ℕ => fun p : ℕ => (p > 0 ∧ ∀ s ≥ 1, g s = g (s + p))) +(kadistinct : ℕ → (ℕ → ℕ) → Prop) +(hkadistinct : kadistinct = fun k : ℕ => fun a : ℕ → ℕ => (k ≥ 1 ∧ ∀ i j : Fin k, i ≠ j → a i ≠ a j)) +(gpeq : (ℕ → ℕ) → ℕ → Prop) +(hgpeq : gpeq = fun g : ℕ → ℕ => fun p : ℕ => (p > 0 ∧ ∀ s ≥ 1, g s = g (s + p))) (hlastnzdig : ∀ digs : List ℕ, (∃ i : Fin digs.length, digs[i] ≠ 0) → lastnzdig digs ≠ 0 ∧ (∃ i : Fin digs.length, digs[i] = lastnzdig digs ∧ ∀ j < i, digs[j] = 0)) (hf : ∀ n > 0, f n = lastnzdig (Nat.digits 10 (n)!)) : ∃ g : ℕ → ℕ, (∀ (k : ℕ) (a : ℕ → ℕ), kadistinct k a → g (∑ i : Fin k, a i) = f (∑ i : Fin k, 5 ^ (a i))) ∧ diff --git a/lean4/src/putnam_1985_a5.lean b/lean4/src/putnam_1985_a5.lean index 15a052af..a42b4931 100644 --- a/lean4/src/putnam_1985_a5.lean +++ b/lean4/src/putnam_1985_a5.lean @@ -6,6 +6,7 @@ open Set Filter Topology Real abbrev putnam_1985_a5_solution : Set ℕ := sorry -- {3, 4, 7, 8} theorem putnam_1985_a5 -(I : ℕ → ℝ := fun m ↦ ∫ x in (0)..(2 * Real.pi), ∏ k in Finset.Icc 1 m, cos (k * x)) +(I : ℕ → ℝ) +(hI : I = fun (m : ℕ) ↦ ∫ x in (0)..(2 * Real.pi), ∏ k in Finset.Icc 1 m, cos (k * x)) : ({m ∈ Finset.Icc 1 10 | I m ≠ 0} = putnam_1985_a5_solution) := sorry diff --git a/lean4/src/putnam_1985_a6.lean b/lean4/src/putnam_1985_a6.lean index e75d8b3d..8645b5f7 100644 --- a/lean4/src/putnam_1985_a6.lean +++ b/lean4/src/putnam_1985_a6.lean @@ -6,7 +6,9 @@ open Set Filter Topology Real Polynomial noncomputable abbrev putnam_1985_a6_solution : Polynomial ℝ := sorry -- 6 * X ^ 2 + 5 * X + 1 theorem putnam_1985_a6 -(Γ : Polynomial ℝ → ℝ := fun p ↦ ∑ k in Finset.range (p.natDegree + 1), coeff p k ^ 2) -(f : Polynomial ℝ := 3 * X ^ 2 + 7 * X + 2) +(Γ : Polynomial ℝ → ℝ) +(hΓ : Γ = fun p ↦ ∑ k in Finset.range (p.natDegree + 1), coeff p k ^ 2) +(f : Polynomial ℝ) +(hf : f = 3 * X ^ 2 + 7 * X + 2) : (let g := putnam_1985_a6_solution; g.eval 0 = 1 ∧ ∀ n : ℕ, n ≥ 1 → Γ (f ^ n) = Γ (g ^ n)) := sorry diff --git a/lean4/src/putnam_1985_b1.lean b/lean4/src/putnam_1985_b1.lean index 7c0f871c..32295c77 100644 --- a/lean4/src/putnam_1985_b1.lean +++ b/lean4/src/putnam_1985_b1.lean @@ -6,7 +6,9 @@ open Set Filter Topology Real Polynomial Function abbrev putnam_1985_b1_solution : Fin 5 → ℤ := sorry -- fun i ↦ i - 2 theorem putnam_1985_b1 -(p : (Fin 5 → ℤ) → (Polynomial ℝ) := fun m ↦ ∏ i : Fin 5, ((X : Polynomial ℝ) - m i)) -(numnzcoeff : Polynomial ℝ → ℕ := fun p ↦ {j ∈ Finset.range (p.natDegree + 1) | coeff p j ≠ 0}.ncard) +(p : (Fin 5 → ℤ) → (Polynomial ℝ)) +(hp : p = fun m ↦ ∏ i : Fin 5, ((X : Polynomial ℝ) - m i)) +(numnzcoeff : Polynomial ℝ → ℕ) +(hnumnzcoeff : numnzcoeff = fun p ↦ {j ∈ Finset.range (p.natDegree + 1) | coeff p j ≠ 0}.ncard) : (Injective putnam_1985_b1_solution ∧ ∀ m : Fin 5 → ℤ, Injective m → numnzcoeff (p putnam_1985_b1_solution) ≤ numnzcoeff (p m)) := sorry diff --git a/lean4/src/putnam_1986_a1.lean b/lean4/src/putnam_1986_a1.lean index d2448128..3edbc8dc 100644 --- a/lean4/src/putnam_1986_a1.lean +++ b/lean4/src/putnam_1986_a1.lean @@ -4,7 +4,9 @@ open BigOperators abbrev putnam_1986_a1_solution : ℝ := sorry -- 18 theorem putnam_1986_a1 -(S : Set ℝ := {x : ℝ | x ^ 4 + 36 ≤ 13 * x ^ 2}) -(f : ℝ → ℝ := fun x ↦ x ^ 3 - 3 * x) +(S : Set ℝ) +(hS : S = {x : ℝ | x ^ 4 + 36 ≤ 13 * x ^ 2}) +(f : ℝ → ℝ) +(hf : f = fun x ↦ x ^ 3 - 3 * x) : (∀ x ∈ S, f x ≤ putnam_1986_a1_solution ∧ ∃ x ∈ S, f x = putnam_1986_a1_solution) := sorry diff --git a/lean4/src/putnam_1986_a3.lean b/lean4/src/putnam_1986_a3.lean index 8a23868f..852602ab 100644 --- a/lean4/src/putnam_1986_a3.lean +++ b/lean4/src/putnam_1986_a3.lean @@ -6,7 +6,8 @@ open Real noncomputable abbrev putnam_1986_a3_solution : ℝ := sorry -- Real.pi / 2 theorem putnam_1986_a3 -(cot : ℝ → ℝ := fun θ ↦ cos θ / sin θ) +(cot : ℝ → ℝ) +(fcot : cot = fun θ ↦ cos θ / sin θ) (arccot : ℝ → ℝ) (harccot : ∀ t : ℝ, t ≥ 0 → arccot t ∈ Set.Ioc 0 (Real.pi / 2) ∧ cot (arccot t) = t) : (∑' n : ℕ, arccot (n ^ 2 + n + 1) = putnam_1986_a3_solution) := diff --git a/lean4/src/putnam_1986_a4.lean b/lean4/src/putnam_1986_a4.lean index caa87795..d601c84b 100644 --- a/lean4/src/putnam_1986_a4.lean +++ b/lean4/src/putnam_1986_a4.lean @@ -6,7 +6,8 @@ open Real Equiv abbrev putnam_1986_a4_solution : ℚ × ℚ × ℚ × ℚ × ℚ × ℚ × ℚ := sorry -- (1, 4, 2, 3, -4, 2, 1) theorem putnam_1986_a4 -(f : ℕ → ℕ := fun n ↦ {A : Matrix (Fin n) (Fin n) ℤ | (∀ i j : Fin n, A i j ∈ ({-1, 0, 1} : Set ℤ)) ∧ ∃ S : ℤ, ∀ ϕ : Perm (Fin n), ∑ i : Fin n, A i (ϕ i) = S}.ncard) +(f : ℕ → ℕ) +(hf : f = fun n ↦ {A : Matrix (Fin n) (Fin n) ℤ | (∀ i j : Fin n, A i j ∈ ({-1, 0, 1} : Set ℤ)) ∧ ∃ S : ℤ, ∀ ϕ : Perm (Fin n), ∑ i : Fin n, A i (ϕ i) = S}.ncard) : let (a1, b1, a2, b2, a3, b3, a4) := putnam_1986_a4_solution; (∀ n > 0, f n = a1 * b1 ^ n + a2 * b2 ^ n + a3 * b3 ^ n + a4) := sorry diff --git a/lean4/src/putnam_1986_a5.lean b/lean4/src/putnam_1986_a5.lean index f71400d7..383b2221 100644 --- a/lean4/src/putnam_1986_a5.lean +++ b/lean4/src/putnam_1986_a5.lean @@ -6,10 +6,13 @@ open Real Equiv theorem putnam_1986_a5 (n : ℕ) (f : Fin n → ((Fin n → ℝ) → ℝ)) -(xrepl : (Fin n → ℝ) → Fin n → ℝ → (Fin n → ℝ) := (fun (x : Fin n → ℝ) (i : Fin n) (xi : ℝ) => (fun j : Fin n => if j = i then xi else x j))) -(contdiffx : ((Fin n → ℝ) → ℝ) → Fin n → (Fin n → ℝ) → Prop := (fun (func : (Fin n → ℝ) → ℝ) (i : Fin n) (x : Fin n → ℝ) => ContDiff ℝ 1 (fun xi : ℝ => func (xrepl x i xi)))) -(partderiv : ((Fin n → ℝ) → ℝ) → Fin n → ((Fin n → ℝ) → ℝ) := (fun (func : (Fin n → ℝ) → ℝ) (i : Fin n) => (fun x : Fin n → ℝ => deriv (fun xi : ℝ => func (xrepl x i xi)) (x i)))) +(xrepl : (Fin n → ℝ) → Fin n → ℝ → (Fin n → ℝ)) +(contdiffx : ((Fin n → ℝ) → ℝ) → Fin n → (Fin n → ℝ) → Prop) +(partderiv : ((Fin n → ℝ) → ℝ) → Fin n → ((Fin n → ℝ) → ℝ)) +(hpartderiv : partderiv = (fun (func : (Fin n → ℝ) → ℝ) (i : Fin n) => (fun x : Fin n → ℝ => deriv (fun xi : ℝ => func (xrepl x i xi)) (x i)))) (npos : n ≥ 1) +(hxrepl : xrepl = (fun (x : Fin n → ℝ) (i : Fin n) (xi : ℝ) => (fun j : Fin n => if j = i then xi else x j))) +(hcontdiffx : contdiffx = (fun (func : (Fin n → ℝ) → ℝ) (i : Fin n) (x : Fin n → ℝ) => ContDiff ℝ 1 (fun xi : ℝ => func (xrepl x i xi)))) (hfcontdiff1 : ∀ i : Fin n, ∀ j : Fin n, ∀ x : Fin n → ℝ, contdiffx (f i) j x) (hfcontdiff2 : ∀ i : Fin n, ∀ j1 j2 : Fin n, ∀ x : Fin n → ℝ, contdiffx (partderiv (f i) j1) j2 x) (hfc : ∃ c : Fin n → Fin n → ℝ, ∀ i j : Fin n, partderiv (f i) j - partderiv (f j) i = (fun x : Fin n → ℝ => c i j)) diff --git a/lean4/src/putnam_1986_b3.lean b/lean4/src/putnam_1986_b3.lean index 23131831..75d268ad 100644 --- a/lean4/src/putnam_1986_b3.lean +++ b/lean4/src/putnam_1986_b3.lean @@ -4,7 +4,8 @@ open BigOperators open Real Equiv Polynomial theorem putnam_1986_b3 -(cong : Polynomial ℤ → Polynomial ℤ → ℤ → Prop := fun f g m ↦ ∀ i : ℕ, m ∣ (f - g).coeff i) +(cong : Polynomial ℤ → Polynomial ℤ → ℤ → Prop) +(hcong : cong = fun f g m ↦ ∀ i : ℕ, m ∣ (f - g).coeff i) (n p : ℕ) (nppos : n > 0 ∧ p > 0) (pprime : Nat.Prime p) diff --git a/lean4/src/putnam_1986_b5.lean b/lean4/src/putnam_1986_b5.lean index a10d1311..9871e6a8 100644 --- a/lean4/src/putnam_1986_b5.lean +++ b/lean4/src/putnam_1986_b5.lean @@ -6,7 +6,9 @@ open Real Equiv Polynomial Filter Topology MvPolynomial abbrev putnam_1986_b5_solution : Prop := sorry -- False theorem putnam_1986_b5 -(f : MvPolynomial (Fin 3) ℝ := (X 0) ^ 2 + (X 1) ^ 2 + (X 2) ^ 2 + (X 0) * (X 1) * (X 2)) -(perms : Set (Set (MvPolynomial (Fin 3) ℝ)) := {{X 0, X 1, X 2}, {X 0, -X 1, -X 2}, {-X 0, X 1, -X 2}, {-X 0, -X 1, X 2}}) +(f : MvPolynomial (Fin 3) ℝ) +(hf : f = (X 0) ^ 2 + (X 1) ^ 2 + (X 2) ^ 2 + (X 0) * (X 1) * (X 2)) +(perms : Set (Set (MvPolynomial (Fin 3) ℝ))) +(hperms : perms = {{X 0, X 1, X 2}, {X 0, -X 1, -X 2}, {-X 0, X 1, -X 2}, {-X 0, -X 1, X 2}}) : ((∀ pqr : Fin 3 → MvPolynomial (Fin 3) ℝ, (∀ xyz : Fin 3 → ℝ, MvPolynomial.eval (fun i ↦ MvPolynomial.eval xyz (pqr i)) f = MvPolynomial.eval xyz f) → ({pqr 0, pqr 1, pqr 2} ∈ perms)) ↔ putnam_1986_b5_solution) := sorry diff --git a/lean4/src/putnam_1987_a4.lean b/lean4/src/putnam_1987_a4.lean index 55ebda82..28cd4d76 100644 --- a/lean4/src/putnam_1987_a4.lean +++ b/lean4/src/putnam_1987_a4.lean @@ -9,7 +9,8 @@ theorem putnam_1987_a4 (P : MvPolynomial (Fin 3) ℂ) (hPreal : ∀ i : Fin 3 →₀ ℕ, (coeff i P).im = 0) (F : ℝ → ℝ → ℝ) -(vars : ℂ → ℂ → ℂ → (Fin 3 → ℂ) := fun a b c ↦ fun i ↦ ite (i = 0) a (ite (i = 1) b c)) +(vars : ℂ → ℂ → ℂ → (Fin 3 → ℂ)) +(hvars : vars = fun a b c ↦ fun i ↦ ite (i = 0) a (ite (i = 1) b c)) (h : ∀ x y z u : ℝ, eval (vars (u * x) (u * y) (u * z)) P = u ^ 2 * F (y - x) (z - x)) (hPval : eval (vars 1 0 0) P = 4 ∧ eval (vars 0 1 0) P = 5 ∧ eval (vars 0 0 1) P = 6) (A B C : ℂ) diff --git a/lean4/src/putnam_1987_a5.lean b/lean4/src/putnam_1987_a5.lean index f585ad0c..5e95cbca 100644 --- a/lean4/src/putnam_1987_a5.lean +++ b/lean4/src/putnam_1987_a5.lean @@ -8,13 +8,18 @@ abbrev putnam_1987_a5_solution : Prop := sorry theorem putnam_1987_a5 (vec2 : ℝ → ℝ → (Fin 2 → ℝ)) (vec3 : ℝ → ℝ → ℝ → (Fin 3 → ℝ)) -(G : (Fin 2 → ℝ) → (Fin 3 → ℝ) := (fun v : Fin 2 → ℝ => vec3 (-v 1 / ((v 0) ^ 2 + 4 * (v 1) ^ 2)) (v 0 / ((v 0) ^ 2 + 4 * (v 1) ^ 2)) 0)) -(vrepl : (Fin 3 → ℝ) → Fin 3 → ℝ → (Fin 3 → ℝ) := (fun (v : Fin 3 → ℝ) (i : Fin 3) (vi : ℝ) => (fun j : Fin 3 => if j = i then vi else v j))) -(contdiffv : ((Fin 3 → ℝ) → ℝ) → Fin 3 → (Fin 3 → ℝ) → Prop := (fun (Fi : (Fin 3 → ℝ) → ℝ) (j : Fin 3) (v : Fin 3 → ℝ) => ContDiffAt ℝ 1 (fun vj : ℝ => Fi (vrepl v j vj)) (v j))) -(partderiv : ((Fin 3 → ℝ) → ℝ) → Fin 3 → ((Fin 3 → ℝ) → ℝ) := (fun (Fi : (Fin 3 → ℝ) → ℝ) (j : Fin 3) => (fun v : Fin 3 → ℝ => deriv (fun vj : ℝ => Fi (vrepl v j vj)) (v j)))) -(Fprop1 : (Fin 3 → ((Fin 3 → ℝ) → ℝ)) → Prop := (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ i : Fin 3, ∀ j : Fin 3, ∀ v ≠ 0, contdiffv (F i) j v)) -(Fprop2 : (Fin 3 → ((Fin 3 → ℝ) → ℝ)) → Prop := (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ v ≠ 0, vec3 ((partderiv (F 2) 1 - partderiv (F 1) 2) v) ((partderiv (F 0) 2 - partderiv (F 2) 0) v) ((partderiv (F 1) 0 - partderiv (F 0) 1) v) = 0)) -(Fprop3 : (Fin 3 → ((Fin 3 → ℝ) → ℝ)) → Prop := (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ x y : ℝ, (fun i : Fin 3 => (F i) (vec3 x y 0)) = G (vec2 x y))) +(G : (Fin 2 → ℝ) → (Fin 3 → ℝ)) +(hG : G = (fun v : Fin 2 → ℝ => vec3 (-v 1 / ((v 0) ^ 2 + 4 * (v 1) ^ 2)) (v 0 / ((v 0) ^ 2 + 4 * (v 1) ^ 2)) 0)) +(vrepl : (Fin 3 → ℝ) → Fin 3 → ℝ → (Fin 3 → ℝ)) +(hvrepl : vrepl = (fun (v : Fin 3 → ℝ) (i : Fin 3) (vi : ℝ) => (fun j : Fin 3 => if j = i then vi else v j))) +(contdiffv : ((Fin 3 → ℝ) → ℝ) → Fin 3 → (Fin 3 → ℝ) → Prop) +(hcontdiffv : contdiffv = (fun (Fi : (Fin 3 → ℝ) → ℝ) (j : Fin 3) (v : Fin 3 → ℝ) => ContDiffAt ℝ 1 (fun vj : ℝ => Fi (vrepl v j vj)) (v j))) +(partderiv : ((Fin 3 → ℝ) → ℝ) → Fin 3 → ((Fin 3 → ℝ) → ℝ)) +(hpartderiv : partderiv = (fun (Fi : (Fin 3 → ℝ) → ℝ) (j : Fin 3) => (fun v : Fin 3 → ℝ => deriv (fun vj : ℝ => Fi (vrepl v j vj)) (v j)))) +(Fprop1 Fprop2 Fprop3 : (Fin 3 → ((Fin 3 → ℝ) → ℝ)) → Prop) +(hFprop1 : Fprop1 = (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ i : Fin 3, ∀ j : Fin 3, ∀ v ≠ 0, contdiffv (F i) j v)) +(hFprop2 : Fprop2 = (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ v ≠ 0, vec3 ((partderiv (F 2) 1 - partderiv (F 1) 2) v) ((partderiv (F 0) 2 - partderiv (F 2) 0) v) ((partderiv (F 1) 0 - partderiv (F 0) 1) v) = 0)) +(hFprop3 : Fprop3 = (fun F : Fin 3 → ((Fin 3 → ℝ) → ℝ) => ∀ x y : ℝ, (fun i : Fin 3 => (F i) (vec3 x y 0)) = G (vec2 x y))) (hvec2 : ∀ x y : ℝ, (vec2 x y) 0 = x ∧ (vec2 x y) 1 = y) (hvec3 : ∀ x y z : ℝ, (vec3 x y z) 0 = x ∧ (vec3 x y z) 1 = y ∧ (vec3 x y z) 2 = z) : (∃ F : Fin 3 → ((Fin 3 → ℝ) → ℝ), Fprop1 F ∧ Fprop2 F ∧ Fprop3 F) ↔ putnam_1987_a5_solution := diff --git a/lean4/src/putnam_1987_a6.lean b/lean4/src/putnam_1987_a6.lean index b4b76004..b12901f2 100644 --- a/lean4/src/putnam_1987_a6.lean +++ b/lean4/src/putnam_1987_a6.lean @@ -6,6 +6,7 @@ open MvPolynomial Real Nat abbrev putnam_1987_a6_solution : Set ℝ := sorry -- {x : ℝ | x > 0 ∧ x < 25} theorem putnam_1987_a6 -(a : ℕ → ℕ := fun n ↦ {i | (digits 3 n).get i = 0}.ncard) +(a : ℕ → ℕ) +(ha : a = fun n ↦ {i | (digits 3 n).get i = 0}.ncard) : ({x : ℝ | x > 0 ∧ Summable (fun n ↦ x ^ (a n) / (n ^ 3))} = putnam_1987_a6_solution) := sorry diff --git a/lean4/src/putnam_1987_b6.lean b/lean4/src/putnam_1987_b6.lean index 4ba31514..4d1a8d63 100644 --- a/lean4/src/putnam_1987_b6.lean +++ b/lean4/src/putnam_1987_b6.lean @@ -12,6 +12,7 @@ theorem putnam_1987_b6 (Snz : ∀ x ∈ S, x ≠ 0) (Scard : S.ncard = ((p : ℤ) ^ 2 - 1) / 2) (hS : ∀ a : F, a ≠ 0 → Xor' (a ∈ S) (-a ∈ S)) -(N : ℕ := (S ∩ {x | ∃ a ∈ S, x = 2 * a}).ncard) +(N : ℕ) +(hN : N = (S ∩ {x | ∃ a ∈ S, x = 2 * a}).ncard) : (Even N) := -sorry \ No newline at end of file +sorry diff --git a/lean4/src/putnam_1988_a1.lean b/lean4/src/putnam_1988_a1.lean index c4af1b1e..b181ab04 100644 --- a/lean4/src/putnam_1988_a1.lean +++ b/lean4/src/putnam_1988_a1.lean @@ -4,6 +4,7 @@ open BigOperators abbrev putnam_1988_a1_solution : ℝ := sorry -- 6 theorem putnam_1988_a1 -(R : Set (Fin 2 → ℝ) := {p : Fin 2 → ℝ | |p 0| - |p 1| ≤ 1 ∧ |p 1| ≤ 1}) +(R : Set (Fin 2 → ℝ)) +(hR : R = {p : Fin 2 → ℝ | |p 0| - |p 1| ≤ 1 ∧ |p 1| ≤ 1}) : (MeasureTheory.volume R).toReal = putnam_1988_a1_solution := sorry diff --git a/lean4/src/putnam_1988_a2.lean b/lean4/src/putnam_1988_a2.lean index a6b2fc9c..c73648e6 100644 --- a/lean4/src/putnam_1988_a2.lean +++ b/lean4/src/putnam_1988_a2.lean @@ -6,6 +6,7 @@ open Set abbrev putnam_1988_a2_solution : Prop := sorry -- True theorem putnam_1988_a2 -(f : ℝ → ℝ := fun x ↦ Real.exp (x ^ 2)) +(f : ℝ → ℝ) +(hf : f = fun x ↦ Real.exp (x ^ 2)) : ((∃ a b : ℝ, a < b ∧ ∃ g : ℝ → ℝ, (∃ x ∈ Ioo a b, g x ≠ 0) ∧ DifferentiableOn ℝ g (Ioo a b) ∧ ∀ x ∈ Ioo a b, deriv (fun y ↦ f y * g y) x = (deriv f x) * (deriv g x)) ↔ putnam_1988_a2_solution) := sorry diff --git a/lean4/src/putnam_1988_a4.lean b/lean4/src/putnam_1988_a4.lean index a2470935..4977f451 100644 --- a/lean4/src/putnam_1988_a4.lean +++ b/lean4/src/putnam_1988_a4.lean @@ -6,6 +6,7 @@ open Set Filter Topology abbrev putnam_1988_a4_solution : Prop × Prop := sorry -- (True, False) theorem putnam_1988_a4 -(p : ℕ → Prop := fun n ↦ ∀ color : (EuclideanSpace ℝ (Fin 2)) → Fin n, ∃ p q : EuclideanSpace ℝ (Fin 2), color p = color q ∧ dist p q = 1) +(p : ℕ → Prop) +(hp : p = fun n ↦ ∀ color : (EuclideanSpace ℝ (Fin 2)) → Fin n, ∃ p q : EuclideanSpace ℝ (Fin 2), color p = color q ∧ dist p q = 1) : (let (a, b) := putnam_1988_a4_solution; (p 3 ↔ a) ∧ (p 9 ↔ b)) := sorry diff --git a/lean4/src/putnam_1989_b1.lean b/lean4/src/putnam_1989_b1.lean index 0721cd2b..f4d37577 100644 --- a/lean4/src/putnam_1989_b1.lean +++ b/lean4/src/putnam_1989_b1.lean @@ -6,10 +6,14 @@ open Nat abbrev putnam_1989_b1_solution : ℤ × ℤ × ℤ × ℤ := sorry -- (4, 2, -5, 3) theorem putnam_1989_b1 -(square : Set (EuclideanSpace ℝ (Fin 2)) := {p : EuclideanSpace ℝ (Fin 2) | ∀ i : Fin 2, p i ∈ Set.Icc 0 1}) -(edges : Set (EuclideanSpace ℝ (Fin 2)) := {p ∈ square | p 0 = 0 ∨ p 0 = 1 ∨ p 1 = 0 ∨ p 1 = 1}) -(center : EuclideanSpace ℝ (Fin 2) := (fun i : Fin 2 => 1 / 2)) -(Scloser : Set (EuclideanSpace ℝ (Fin 2)) := {p ∈ square | ∀ q ∈ edges, dist p center < dist p q}) +(square : Set (EuclideanSpace ℝ (Fin 2))) +(square_def : square = {p : EuclideanSpace ℝ (Fin 2) | ∀ i : Fin 2, p i ∈ Set.Icc 0 1}) +(perimeter : Set (EuclideanSpace ℝ (Fin 2))) +(perimeter_def : perimeter = {p ∈ square | p 0 = 0 ∨ p 0 = 1 ∨ p 1 = 0 ∨ p 1 = 1}) +(center : EuclideanSpace ℝ (Fin 2)) +(center_def : center = (fun i : Fin 2 => 1 / 2)) +(Scloser : Set (EuclideanSpace ℝ (Fin 2))) +(hScloser : Scloser = {p ∈ square | ∀ q ∈ perimeter, dist p center < dist p q}) : let (a, b, c, d) := putnam_1989_b1_solution; b > 0 ∧ d > 0 ∧ (¬∃ n : ℤ, n^2 = b) ∧ (MeasureTheory.volume Scloser).toReal / (MeasureTheory.volume square).toReal = (a * Real.sqrt b + c) / d := sorry diff --git a/lean4/src/putnam_1989_b6.lean b/lean4/src/putnam_1989_b6.lean index e90f8074..92773b33 100644 --- a/lean4/src/putnam_1989_b6.lean +++ b/lean4/src/putnam_1989_b6.lean @@ -6,11 +6,15 @@ open Nat Filter Topology Set -- Note: uses (ℝ → ℝ) instead of (Set.Icc 0 1 → ℝ) theorem putnam_1989_b6 (n : ℕ) -(Sx : Set (Fin n → ℝ) := {x : Fin n → ℝ | 0 < x ∧ StrictMono x ∧ x < 1}) -(fprop : (ℝ → ℝ) → Prop := (fun f : ℝ → ℝ => ContinuousOn f (Set.Icc 0 1) ∧ f 1 = 0)) +(Sx : Set (Fin n → ℝ)) +(fprop : (ℝ → ℝ) → Prop) (xext : (Fin n → ℝ) → (ℕ → ℝ)) -(fxsum : (ℝ → ℝ) → (Fin n → ℝ) → ℝ := (fun (f : ℝ → ℝ) (x : Fin n → ℝ) => ∑ i in Finset.Icc 0 n, ((xext x) (i + 1) - (xext x) i) * f ((xext x) (i + 1)))) -(fEV : (ℝ → ℝ) → ℝ := (fun f : ℝ → ℝ => (∫ x in Sx, fxsum f x) / (∫ x in Sx, 1))) +(fxsum : (ℝ → ℝ) → (Fin n → ℝ) → ℝ) +(fEV : (ℝ → ℝ) → ℝ) +(hSx : Sx = {x : Fin n → ℝ | 0 < x ∧ StrictMono x ∧ x < 1}) +(hfprop : fprop = (fun f : ℝ → ℝ => ContinuousOn f (Set.Icc 0 1) ∧ f 1 = 0)) +(hfxsum : fxsum = (fun (f : ℝ → ℝ) (x : Fin n → ℝ) => ∑ i in Finset.Icc 0 n, ((xext x) (i + 1) - (xext x) i) * f ((xext x) (i + 1)))) +(hfEV : fEV = (fun f : ℝ → ℝ => (∫ x in Sx, fxsum f x) / (∫ x in Sx, 1))) (npos : n ≥ 1) (hxext : ∀ x : Fin n → ℝ, (xext x) 0 = 0 ∧ (xext x) (n + 1) = 1 ∧ (∀ i : Fin n, (xext x) (i + 1) = x i)) : ∃ P : Polynomial ℝ, P.degree = n ∧ (∀ t ∈ Set.Icc 0 1, 0 ≤ P.eval t ∧ P.eval t ≤ 1) ∧ (∀ f : ℝ → ℝ, fprop f → fEV f = (∫ t in Set.Ioo 0 1, f t * P.eval t)) := diff --git a/lean4/src/putnam_1992_a2.lean b/lean4/src/putnam_1992_a2.lean index 3b46ddd1..d3defc82 100644 --- a/lean4/src/putnam_1992_a2.lean +++ b/lean4/src/putnam_1992_a2.lean @@ -6,6 +6,7 @@ open Topology Filter abbrev putnam_1992_a2_solution : ℝ := sorry -- 1992 theorem putnam_1992_a2 -(C : ℝ → ℝ := fun α ↦ taylorCoeffWithin (fun x ↦ (1 + x) ^ α) 1992 Set.univ 0) +(C : ℝ → ℝ) +(hC : C = fun α ↦ taylorCoeffWithin (fun x ↦ (1 + x) ^ α) 1992 Set.univ 0) : (∫ y in (0)..1, C (-y - 1) * ∑ k in Finset.Icc (1 : ℕ) 1992, 1 / (y + k) = putnam_1992_a2_solution) := sorry diff --git a/lean4/src/putnam_1992_a5.lean b/lean4/src/putnam_1992_a5.lean index b1f86b3a..bcbb0e02 100644 --- a/lean4/src/putnam_1992_a5.lean +++ b/lean4/src/putnam_1992_a5.lean @@ -4,6 +4,7 @@ open BigOperators open Topology Filter Nat Function theorem putnam_1992_a5 -(a : ℕ → ℕ := fun n ↦ ite (Even {i | (digits 2 n).get i = 1}.ncard) 0 1) +(a : ℕ → ℕ) +(ha : a = fun n ↦ ite (Even {i | (digits 2 n).get i = 1}.ncard) 0 1) : (¬∃ k > 0, ∃ m > 0, ∀ j ≤ m - 1, a (k + j) = a (k + m + j) ∧ a (k + m + j) = a (k + 2 * m + j)) := sorry diff --git a/lean4/src/putnam_1992_b1.lean b/lean4/src/putnam_1992_b1.lean index 3f679314..ba1ebae7 100644 --- a/lean4/src/putnam_1992_b1.lean +++ b/lean4/src/putnam_1992_b1.lean @@ -8,7 +8,8 @@ abbrev putnam_1992_b1_solution : ℕ → ℤ := sorry theorem putnam_1992_b1 (n : ℕ) (nge2 : n ≥ 2) -(A : Finset ℝ → Set ℝ := fun S ↦ {x | ∃ a ∈ S, ∃ b ∈ S, a ≠ b ∧ (a + b) / 2 = x}) +(A : Finset ℝ → Set ℝ) +(hA : A = fun S ↦ {x | ∃ a ∈ S, ∃ b ∈ S, a ≠ b ∧ (a + b) / 2 = x}) (min : ℤ) (hmineq : ∃ S : Finset ℝ, S.card = n ∧ min = (A S).ncard) (hminlb : ∀ S : Finset ℝ, S.card = n → min ≤ (A S).ncard) diff --git a/lean4/src/putnam_1992_b2.lean b/lean4/src/putnam_1992_b2.lean index 17dd2142..f88cb000 100644 --- a/lean4/src/putnam_1992_b2.lean +++ b/lean4/src/putnam_1992_b2.lean @@ -4,6 +4,7 @@ open BigOperators open Topology Filter Nat Function Polynomial theorem putnam_1992_b2 -(Q : ℕ → ℕ → ℕ := fun n k ↦ coeff ((1 + X + X ^ 2 + X ^ 3) ^ n) k) +(Q : ℕ → ℕ → ℕ) +(hQ : Q = fun n k ↦ coeff ((1 + X + X ^ 2 + X ^ 3) ^ n) k) : (∀ n k : ℕ, Q n k = ∑ j : Finset.range (k + 1), choose n j * choose n (k - 2 * j)) := sorry diff --git a/lean4/src/putnam_1992_b4.lean b/lean4/src/putnam_1992_b4.lean index 52ee3054..75160820 100644 --- a/lean4/src/putnam_1992_b4.lean +++ b/lean4/src/putnam_1992_b4.lean @@ -6,8 +6,10 @@ open Topology Filter Nat Function Polynomial abbrev putnam_1992_b4_solution : ℕ := sorry -- 3984 theorem putnam_1992_b4 -(valid : Polynomial ℝ → Prop := fun p ↦ p ≠ 0 ∧ p.degree < 1992 ∧ IsCoprime p (X ^ 3 - X)) -(pair : Polynomial ℝ → Polynomial ℝ → Prop := fun p f ↦ ∃ g : Polynomial ℝ, iteratedDeriv 1992 (fun x ↦ p.eval x / (x ^ 3 - x)) = fun x ↦ f.eval x / g.eval x) +(valid : Polynomial ℝ → Prop) +(hvalid : valid = fun p ↦ p ≠ 0 ∧ p.degree < 1992 ∧ IsCoprime p (X ^ 3 - X)) +(pair : Polynomial ℝ → Polynomial ℝ → Prop) +(hpair : pair = fun p f ↦ ∃ g : Polynomial ℝ, iteratedDeriv 1992 (fun x ↦ p.eval x / (x ^ 3 - x)) = fun x ↦ f.eval x / g.eval x) (min : ℕ) (hmineq : ∃ p f : Polynomial ℝ, (valid p ∧ pair p f) ∧ min = f.degree) (hminlb : ∀ p f : Polynomial ℝ, (valid p ∧ pair p f) → min ≤ f.degree) diff --git a/lean4/src/putnam_1992_b5.lean b/lean4/src/putnam_1992_b5.lean index cca7a8cc..4289e0f4 100644 --- a/lean4/src/putnam_1992_b5.lean +++ b/lean4/src/putnam_1992_b5.lean @@ -6,6 +6,7 @@ open Topology Filter Nat Function Polynomial abbrev putnam_1992_b5_solution : Prop := sorry -- False theorem putnam_1992_b5 -(D : ℕ → ℚ := fun n ↦ Matrix.det (fun i j : Fin (n - 1) ↦ ite (i = j) (i + 3) 1)) +(D : ℕ → ℚ) +(hD : D = fun (n : ℕ) ↦ Matrix.det (fun i j : Fin (n - 1) ↦ ite (i = j) ((i : ℕ) + 3 : ℚ) 1)) : ((Bornology.IsBounded {x | ∃ n ≥ 2, D n / factorial n = x}) ↔ putnam_1992_b5_solution) := sorry diff --git a/lean4/src/putnam_1993_b3.lean b/lean4/src/putnam_1993_b3.lean index 10dd867e..ca0faf67 100644 --- a/lean4/src/putnam_1993_b3.lean +++ b/lean4/src/putnam_1993_b3.lean @@ -4,6 +4,7 @@ open BigOperators abbrev putnam_1993_b3_solution : ℚ × ℚ := sorry -- (5 / 4, -1 / 4) theorem putnam_1993_b3 -(S : Set (Fin 2 → ℝ) := {p : Fin 2 → ℝ | 0 < p ∧ p < 1 ∧ Even (round (p 0 / p 1))}) +(S : Set (Fin 2 → ℝ)) +(hS : S = {p : Fin 2 → ℝ | 0 < p ∧ p < 1 ∧ Even (round (p 0 / p 1))}) : let (r, s) := putnam_1993_b3_solution; (MeasureTheory.volume S).toReal / 1 = r + s * Real.pi := sorry diff --git a/lean4/src/putnam_1994_a3.lean b/lean4/src/putnam_1994_a3.lean index 42511bd7..f69aa307 100644 --- a/lean4/src/putnam_1994_a3.lean +++ b/lean4/src/putnam_1994_a3.lean @@ -5,7 +5,8 @@ open Filter Topology -- Note: The formalization here differs slightly from the original problem statement, in that T is the entire triangle, not just the sides. We adopt the former interpretation because it is simpler to state and maintains the difficulty of the problem. theorem putnam_1994_a3 -(T : Set (EuclideanSpace ℝ (Fin 2)) := convexHull ℝ {![0,0], ![1,0], ![0,1]}) +(T : Set (EuclideanSpace ℝ (Fin 2))) +(hT : T = convexHull ℝ {(WithLp.equiv 2 (EuclideanSpace ℝ (Fin 2))).symm ![0,0], (WithLp.equiv 2 (EuclideanSpace ℝ (Fin 2))).symm ![1,0], (WithLp.equiv 2 (EuclideanSpace ℝ (Fin 2))).symm ![0,1]}) (Tcolors : T → Fin 4) : ∃ p q : T, Tcolors p = Tcolors q ∧ dist p.1 q.1 ≥ 2 - Real.sqrt 2 := sorry diff --git a/lean4/src/putnam_1995_a2.lean b/lean4/src/putnam_1995_a2.lean index daf4282e..68dd9678 100644 --- a/lean4/src/putnam_1995_a2.lean +++ b/lean4/src/putnam_1995_a2.lean @@ -6,7 +6,8 @@ open Filter Topology Real abbrev putnam_1995_a2_solution : Set (ℝ × ℝ) := sorry -- {x | let ⟨a,b⟩ := x; a = b} theorem putnam_1995_a2 -(habconv : (ℝ × ℝ) → Prop := fun ⟨a,b⟩ => +(habconv : (ℝ × ℝ) → Prop) +(habconv_def : habconv = fun ⟨a,b⟩ => ∃ limit : ℝ, Tendsto (fun t : ℝ => ∫ x in (Set.Icc b t), (sqrt (sqrt (x + a) - sqrt x) - sqrt (sqrt x - sqrt (x - b)))) atTop (𝓝 limit)) : ∀ ab : ℝ × ℝ, ab.1 > 0 ∧ ab.2 > 0 → (habconv ab ↔ ab ∈ putnam_1995_a2_solution) := sorry diff --git a/lean4/src/putnam_1995_a3.lean b/lean4/src/putnam_1995_a3.lean index 58a22621..cc511426 100644 --- a/lean4/src/putnam_1995_a3.lean +++ b/lean4/src/putnam_1995_a3.lean @@ -5,7 +5,8 @@ open Filter Topology Real theorem putnam_1995_a3 (relation : (Fin 9 → ℤ) → (Fin 9 → ℤ) → Prop) -(digits_to_num : (Fin 9 → ℤ) → ℤ := fun dig => ∑ i : Fin 9, (dig i) * 10^i.1) +(digits_to_num : (Fin 9 → ℤ) → ℤ) +(hdigits_to_num : digits_to_num = fun dig => ∑ i : Fin 9, (dig i) * 10^i.1) (hrelation : ∀ d e : (Fin 9 → ℤ), relation d e ↔ (∀ i : Fin 9, d i < 10 ∧ d i ≥ 0 ∧ e i < 10 ∧ e i ≥ 0) ∧ (∀ i : Fin 9, 7 ∣ (digits_to_num (fun j : Fin 9 => if j = i then e j else d j)))) : ∀ d e f : (Fin 9 → ℤ), ((relation d e) ∧ (relation e f)) → (∀ i : Fin 9, 7 ∣ d i - f i) := sorry diff --git a/lean4/src/putnam_1995_a5.lean b/lean4/src/putnam_1995_a5.lean index bf75b1e0..28c8c6b1 100644 --- a/lean4/src/putnam_1995_a5.lean +++ b/lean4/src/putnam_1995_a5.lean @@ -6,9 +6,13 @@ open Filter Topology Real abbrev putnam_1995_a5_solution : Prop := sorry -- True theorem putnam_1995_a5 -(hdiffx : (n : ℕ) → (Fin n → (ℝ → ℝ)) → Prop := (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) => ∀ i : Fin n, Differentiable ℝ (x i))) -(ha : (n : ℕ) → (Fin n → Fin n → ℝ) → Prop := (fun (n : ℕ) (a : Fin n → Fin n → ℝ) => ∀ i j : Fin n, a i j > 0)) -(hcomb : (n : ℕ) → (Fin n → (ℝ → ℝ)) → (Fin n → Fin n → ℝ) → Prop := (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) (a : Fin n → Fin n → ℝ) => ∀ t : ℝ, ∀ i : Fin n, (deriv (x i)) t = ∑ j : Fin n, (a i j) * ((x j) t))) -(hxlim : (n : ℕ) → (Fin n → (ℝ → ℝ)) → Prop := (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) => ∀ i : Fin n, Tendsto (x i) atTop (𝓝 0))) +(hdiffx : (n : ℕ) → (Fin n → (ℝ → ℝ)) → Prop) +(ha : (n : ℕ) → (Fin n → Fin n → ℝ) → Prop) +(hcomb : (n : ℕ) → (Fin n → (ℝ → ℝ)) → (Fin n → Fin n → ℝ) → Prop) +(hxlim : (n : ℕ) → (Fin n → (ℝ → ℝ)) → Prop) +(hdiffx_def : hdiffx = (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) => ∀ i : Fin n, Differentiable ℝ (x i))) +(ha_def : ha = (fun (n : ℕ) (a : Fin n → Fin n → ℝ) => ∀ i j : Fin n, a i j > 0)) +(hcomb_def : hcomb = (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) (a : Fin n → Fin n → ℝ) => ∀ t : ℝ, ∀ i : Fin n, (deriv (x i)) t = ∑ j : Fin n, (a i j) * ((x j) t))) +(hxlim_def : hxlim = (fun (n : ℕ) (x : Fin n → (ℝ → ℝ)) => ∀ i : Fin n, Tendsto (x i) atTop (𝓝 0))) : putnam_1995_a5_solution ↔ (∀ (n : ℕ) (x : Fin n → (ℝ → ℝ)) (a : Fin n → Fin n → ℝ), (n > 0 ∧ hdiffx n x ∧ ha n a ∧ hcomb n x a ∧ hxlim n x) → ¬(∀ b : Fin n → ℝ, (∀ t : ℝ, ∑ i : Fin n, (b i) * ((x i) t) = 0) → (∀ i : Fin n, b i = 0))) := sorry diff --git a/lean4/src/putnam_1995_a6.lean b/lean4/src/putnam_1995_a6.lean index 55d92baa..f3f1ab72 100644 --- a/lean4/src/putnam_1995_a6.lean +++ b/lean4/src/putnam_1995_a6.lean @@ -4,8 +4,11 @@ open BigOperators open Filter Topology Real theorem putnam_1995_a6 -(SM : (n : ℕ) → Set (Matrix (Fin 3) (Fin n) ℤ) := (fun n : ℕ => {M : Matrix (Fin 3) (Fin n) ℤ | ∀ j : Fin n, {M i j | i : Fin 3} = {1, 2, 3}})) -(Srowsums : (n : ℕ) → Matrix (Fin 3) (Fin n) ℤ → Set ℤ := (fun (n : ℕ) (M : Matrix (Fin 3) (Fin n) ℤ) => {∑ j : Fin n, M i j | i : Fin 3})) -(sumsprog : (Set ℤ) → Prop := (fun sums : Set ℤ => sums.encard = 3 ∧ (∃ a b c : ℤ, {a, b, c} = sums ∧ b = a + 1 ∧ c = a + 2))) +(SM : (n : ℕ) → Set (Matrix (Fin 3) (Fin n) ℤ)) +(hSM : SM = (fun n : ℕ => {M : Matrix (Fin 3) (Fin n) ℤ | ∀ j : Fin n, {M i j | i : Fin 3} = {1, 2, 3}})) +(Srowsums : (n : ℕ) → Matrix (Fin 3) (Fin n) ℤ → Set ℤ) +(hSrowsums : Srowsums = (fun (n : ℕ) (M : Matrix (Fin 3) (Fin n) ℤ) => {∑ j : Fin n, M i j | i : Fin 3})) +(sumsprog : (Set ℤ) → Prop) +(hsumprog : sumprog = (fun sums : Set ℤ => sums.encard = 3 ∧ (∃ a b c : ℤ, {a, b, c} = sums ∧ b = a + 1 ∧ c = a + 2))) : ∃ n ≥ 1995, {M : (SM n) | sumsprog (Srowsums n M)}.encard ≥ 4 * {M : (SM n) | (Srowsums n M).encard = 1}.encard := sorry diff --git a/lean4/src/putnam_1995_b3.lean b/lean4/src/putnam_1995_b3.lean index d18b0d76..e21ee920 100644 --- a/lean4/src/putnam_1995_b3.lean +++ b/lean4/src/putnam_1995_b3.lean @@ -9,7 +9,9 @@ abbrev putnam_1995_b3_solution : ℕ → ℤ := sorry theorem putnam_1995_b3 (n : ℕ) (hn : n > 0) -(digits_set := {f : ℕ → ℕ | f 0 ≠ 0 ∧ (∀ i : Fin (n ^ 2), f i ≤ 9) ∧ (∀ i ≥ n ^ 2, f i = 0)}) -(digits_to_matrix : (ℕ → ℕ) → Matrix (Fin n) (Fin n) ℤ := fun f => (fun i j => f (i.1 * n + j.1))) +(digits_set : Set (ℕ → ℕ)) +(hdigits_set : digits_set = {f : ℕ → ℕ | f 0 ≠ 0 ∧ (∀ i : Fin (n ^ 2), f i ≤ 9) ∧ (∀ i ≥ n ^ 2, f i = 0)}) +(digits_to_matrix : (ℕ → ℕ) → Matrix (Fin n) (Fin n) ℤ) +(hdigits_to_matrix : digits_to_matrix = fun f => (fun i j => f (i.1 * n + j.1))) : ∑' f : digits_set, (digits_to_matrix f).det = putnam_1995_b3_solution n := sorry diff --git a/lean4/src/putnam_1995_b6.lean b/lean4/src/putnam_1995_b6.lean index 4f3da7c9..b45dc15b 100644 --- a/lean4/src/putnam_1995_b6.lean +++ b/lean4/src/putnam_1995_b6.lean @@ -4,6 +4,7 @@ open BigOperators open Filter Topology Real Nat theorem putnam_1995_b6 -(S : ℝ → Set ℕ := fun α => {x : ℕ | ∃ n : ℕ, n ≥ 1 ∧ x = floor (n * α)}) +(S : ℝ → Set ℕ) +(hS : S = fun (α : ℝ) => {x : ℕ | ∃ n : ℕ, n ≥ 1 ∧ x = floor (n * α)}) : ¬ ∃ α β γ : ℝ, α > 0 ∧ β > 0 ∧ γ > 0 ∧ (S α) ∩ (S β) = ∅ ∧ (S β) ∩ (S γ) = ∅ ∧ (S α) ∩ (S γ) = ∅ ∧ Set.Ici 1 = (S α) ∪ (S β) ∪ (S γ) := sorry diff --git a/lean4/src/putnam_1996_a2.lean b/lean4/src/putnam_1996_a2.lean index a52d054e..30db1cc4 100644 --- a/lean4/src/putnam_1996_a2.lean +++ b/lean4/src/putnam_1996_a2.lean @@ -7,8 +7,9 @@ abbrev putnam_1996_a2_solution : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpac -- (fun O1 O2 : EuclideanSpace ℝ (Fin 2) => {p : EuclideanSpace ℝ (Fin 2) | dist p (midpoint ℝ O1 O2) ≥ 1 ∧ dist p (midpoint ℝ O1 O2) ≤ 2}) theorem putnam_1996_a2 (O1 O2 : EuclideanSpace ℝ (Fin 2)) -(C1 : Set (EuclideanSpace ℝ (Fin 2)) := sphere O1 1) -(C2 : Set (EuclideanSpace ℝ (Fin 2)) := sphere O2 3) +(C1 C2 : Set (EuclideanSpace ℝ (Fin 2))) +(hC1 : C1 = sphere O1 1) +(hC2 : C2 = sphere O2 3) (hO1O2 : dist O1 O2 = 10) : {M : EuclideanSpace ℝ (Fin 2) | ∃ X Y : Fin 2 → ℝ, X ∈ C1 ∧ Y ∈ C2 ∧ M = midpoint ℝ X Y} = putnam_1996_a2_solution O1 O2 := sorry diff --git a/lean4/src/putnam_1996_a5.lean b/lean4/src/putnam_1996_a5.lean index 98e5aaaf..2f548f34 100644 --- a/lean4/src/putnam_1996_a5.lean +++ b/lean4/src/putnam_1996_a5.lean @@ -7,6 +7,7 @@ theorem putnam_1996_a5 (p : ℕ) (hpprime : Prime p) (hpge3 : p > 3) -(k : ℕ := Nat.floor (2*p/(3 : ℚ))) +(k : ℕ) +(hk : k = Nat.floor (2*p/(3 : ℚ))) : p^2 ∣ ∑ i in Finset.Icc 1 k, Nat.choose p i := sorry diff --git a/lean4/src/putnam_1997_a3.lean b/lean4/src/putnam_1997_a3.lean index 0b5bbeb6..da2414d5 100644 --- a/lean4/src/putnam_1997_a3.lean +++ b/lean4/src/putnam_1997_a3.lean @@ -6,7 +6,8 @@ open Filter Topology noncomputable abbrev putnam_1997_a3_solution : ℝ := sorry -- Real.sqrt (Real.exp 1) theorem putnam_1997_a3 -(series1 : ℝ → ℝ := fun x => ∑' n : ℕ, (-1)^n * x^(2*n + 1)/(∏ i : Finset.range n, 2 * ((i : ℝ) + 1))) -(series2 : ℝ → ℝ := fun x => ∑' n : ℕ, x^(2*n)/(∏ i : Finset.range n, (2 * ((i : ℝ) + 1))^2)) +(series1 series2 : ℝ → ℝ) +(hseries1 : series1 = fun x => ∑' n : ℕ, (-1)^n * x^(2*n + 1)/(∏ i : Finset.range n, 2 * ((i : ℝ) + 1))) +(hseries2 : series2 = fun x => ∑' n : ℕ, x^(2*n)/(∏ i : Finset.range n, (2 * ((i : ℝ) + 1))^2)) : Tendsto (fun t => ∫ x in Set.Icc 0 t, series1 x * series2 x) atTop (𝓝 (putnam_1997_a3_solution)) := sorry diff --git a/lean4/src/putnam_1997_a5.lean b/lean4/src/putnam_1997_a5.lean index 46fde0f2..85591cf9 100644 --- a/lean4/src/putnam_1997_a5.lean +++ b/lean4/src/putnam_1997_a5.lean @@ -6,6 +6,7 @@ open Filter Topology abbrev putnam_1997_a5_solution : Prop := sorry -- True theorem putnam_1997_a5 -(N := fun (n : ℕ+) => {t : Fin n → ℕ+ | (∀ i j : Fin n, i < j → t i <= t j) ∧ (∑ i : Fin n, (1 : ℝ)/(t i) = 1) }) +(N : (n : ℕ+) → Set (Fin n → ℕ+)) +(hN : N = fun (n : ℕ+) => {t : Fin n → ℕ+ | (∀ i j : Fin n, i < j → t i <= t j) ∧ (∑ i : Fin n, (1 : ℝ)/(t i) = 1) }) : Odd (N 10).ncard ↔ putnam_1997_a5_solution := sorry diff --git a/lean4/src/putnam_1997_a6.lean b/lean4/src/putnam_1997_a6.lean index cc1501f2..2fc7720f 100644 --- a/lean4/src/putnam_1997_a6.lean +++ b/lean4/src/putnam_1997_a6.lean @@ -13,7 +13,8 @@ theorem putnam_1997_a6 (hx0 : ∀ c : ℝ, x c 0 = 0) (hx1 : ∀ c : ℝ, x c 1 = 1) (hxk : ∀ c : ℝ, ∀ k ≥ 0, x c (k + 2) = (c*(x c (k + 1)) - (n - k)*(x c k))/(k + 1)) -(S : Set ℝ := {c : ℝ | x c (n + 1) = 0}) +(S : Set ℝ) +(hS : S = {c : ℝ | x c (n + 1) = 0}) (hC : C = sSup S) : ∀ k : Set.Icc 1 n, x C k = putnam_1997_a6_solution n k := sorry diff --git a/lean4/src/putnam_1997_b1.lean b/lean4/src/putnam_1997_b1.lean index 65348678..7f975937 100644 --- a/lean4/src/putnam_1997_b1.lean +++ b/lean4/src/putnam_1997_b1.lean @@ -7,6 +7,7 @@ abbrev putnam_1997_b1_solution : ℕ → ℝ := sorry -- fun n => n noncomputable def dist_to_int : ℝ → ℝ := fun r => |r - round r| theorem putnam_1997_b1 -(F : ℕ → ℝ := fun n => ∑ m in Finset.Icc 1 (6 * n - 1), min (dist_to_int (m/(6*n)) ) (dist_to_int (m/(3*n)))) +(F : ℕ → ℝ) +(hF : F = fun (n : ℕ) => ∑ m in Finset.Icc 1 (6 * n - 1), min (dist_to_int (m/(6*n)) ) (dist_to_int (m/(3*n)))) : ∀ n, n > 0 → F n = putnam_1997_b1_solution n := sorry diff --git a/lean4/src/putnam_1998_a2.lean b/lean4/src/putnam_1998_a2.lean index f2a6050a..ee899f52 100644 --- a/lean4/src/putnam_1998_a2.lean +++ b/lean4/src/putnam_1998_a2.lean @@ -2,10 +2,14 @@ import Mathlib open BigOperators theorem putnam_1998_a2 -(quadrant : (EuclideanSpace ℝ (Fin 2)) → Prop := fun P ↦ P 0 > 0 ∧ P 1 > 0 ∧ dist 0 P = 1) -(isarc : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Prop := fun P Q ↦ quadrant P ∧ quadrant Q ∧ P 0 > Q 0) -(arc : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Set (EuclideanSpace ℝ (Fin 2)) := fun P Q ↦ {R : EuclideanSpace ℝ (Fin 2) | quadrant R ∧ P 0 > R 0 ∧ R 0 > Q 0}) -(A : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → ℝ := fun P Q ↦ (MeasureTheory.volume {S : EuclideanSpace ℝ (Fin 2) | ∃ R ∈ arc P Q, R 0 = S 0 ∧ R 1 > S 1 ∧ S 1 > 0}).toReal) -(B : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → ℝ := fun P Q ↦ (MeasureTheory.volume {S : EuclideanSpace ℝ (Fin 2) | ∃ R ∈ arc P Q, R 1 = S 1 ∧ R 0 > S 0 ∧ S 0 > 0}).toReal) +(quadrant : (EuclideanSpace ℝ (Fin 2)) → Prop) +(hquadrant : quadrant = fun P ↦ P 0 > 0 ∧ P 1 > 0 ∧ dist 0 P = 1) +(isarc : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Prop) +(hisarc : isarc = fun P Q ↦ quadrant P ∧ quadrant Q ∧ P 0 > Q 0) +(arc : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Set (EuclideanSpace ℝ (Fin 2))) +(harc : arc = fun P Q ↦ {R : EuclideanSpace ℝ (Fin 2) | quadrant R ∧ P 0 > R 0 ∧ R 0 > Q 0}) +(A B : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → ℝ) +(hA : A = fun P Q ↦ (MeasureTheory.volume {S : EuclideanSpace ℝ (Fin 2) | ∃ R ∈ arc P Q, R 0 = S 0 ∧ R 1 > S 1 ∧ S 1 > 0}).toReal) +(hB : B = fun P Q ↦ (MeasureTheory.volume {S : EuclideanSpace ℝ (Fin 2) | ∃ R ∈ arc P Q, R 1 = S 1 ∧ R 0 > S 0 ∧ S 0 > 0}).toReal) : (∃ f : ℝ → ℝ, ∀ P Q : EuclideanSpace ℝ (Fin 2), isarc P Q → A P Q + B P Q = f (InnerProductGeometry.angle P Q)) := sorry diff --git a/lean4/src/putnam_1998_b4.lean b/lean4/src/putnam_1998_b4.lean index 96652300..5152dd8b 100644 --- a/lean4/src/putnam_1998_b4.lean +++ b/lean4/src/putnam_1998_b4.lean @@ -6,6 +6,7 @@ open Set Function Metric abbrev putnam_1998_b4_solution : Set (ℕ × ℕ) := sorry -- {nm | let ⟨n,m⟩ := nm; multiplicity 2 n ≠ multiplicity 2 m} theorem putnam_1998_b4 -(hsum : ℕ → ℕ → ℤ := fun n m => ∑ i in Finset.range (m * n), (-1)^(i/m + i/n)) -: ∀ n m : ℕ, n > 0 ∧ m > 0 → ((hsum n m) = 0 ↔ ⟨n, m⟩ ∈ putnam_1998_b4_solution) := +(quantity : ℕ → ℕ → ℤ) +(hquantity : quantity = fun n m => ∑ i in Finset.range (m * n), (-1)^(i/m + i/n)) +: ∀ n m : ℕ, n > 0 ∧ m > 0 → ((quantity n m) = 0 ↔ ⟨n, m⟩ ∈ putnam_1998_b4_solution) := sorry diff --git a/lean4/src/putnam_1998_b5.lean b/lean4/src/putnam_1998_b5.lean index 2190e733..24e1190d 100644 --- a/lean4/src/putnam_1998_b5.lean +++ b/lean4/src/putnam_1998_b5.lean @@ -6,6 +6,7 @@ open Set Function Metric abbrev putnam_1998_b5_solution : ℕ := sorry -- 1 theorem putnam_1998_b5 -(N : ℕ := ∑ i in Finset.range 1998, 10^i) +(N : ℕ) +(hN : N = ∑ i in Finset.range 1998, 10^i) : putnam_1998_b5_solution = (Nat.floor (10^1000 * Real.sqrt N)) % 10 := sorry diff --git a/lean4/src/putnam_1999_a3.lean b/lean4/src/putnam_1999_a3.lean index b5c71c7d..13260dfa 100644 --- a/lean4/src/putnam_1999_a3.lean +++ b/lean4/src/putnam_1999_a3.lean @@ -4,7 +4,8 @@ open BigOperators open Filter Topology Metric theorem putnam_1999_a3 -(f : ℝ → ℝ := fun x => 1/(1 - 2 * x - x^2)) +(f : ℝ → ℝ) +(hf : f = fun x => 1/(1 - 2 * x - x^2)) (a : ℕ → ℝ) (hf : ∃ ε > 0, ∀ x ∈ ball 0 ε, Tendsto (λ n => ∑ i in Finset.range n, (a n) * x^n) atTop (𝓝 (f x))) : ∀ n : ℕ, ∃ m : ℕ, (a n)^2 + (a (n + 1))^2 = a m := diff --git a/lean4/src/putnam_1999_b3.lean b/lean4/src/putnam_1999_b3.lean index 87229c8a..fc88f710 100644 --- a/lean4/src/putnam_1999_b3.lean +++ b/lean4/src/putnam_1999_b3.lean @@ -6,7 +6,9 @@ open Filter Topology Metric abbrev putnam_1999_b3_solution : ℝ := sorry -- 3 theorem putnam_1999_b3 -(A : Set (ℝ × ℝ) := {xy : ℝ × ℝ | 0 ≤ xy.1 ∧ xy.1 < 1 ∧ 0 ≤ xy.2 ∧ xy.2 < 1}) -(S : ℝ → ℝ → ℝ := fun x y => ∑' m : ℕ, ∑' n : ℕ, if (m > 0 ∧ n > 0 ∧ 1/2 ≤ m/n ∧ m/n ≤ 2) then x^m * y^n else 0) +(A : Set (ℝ × ℝ)) +(hA : A = {xy : ℝ × ℝ | 0 ≤ xy.1 ∧ xy.1 < 1 ∧ 0 ≤ xy.2 ∧ xy.2 < 1}) +(S : ℝ → ℝ → ℝ) +(hS : S = fun x y => ∑' m : ℕ, ∑' n : ℕ, if (m > 0 ∧ n > 0 ∧ 1/2 ≤ m/n ∧ m/n ≤ 2) then x^m * y^n else 0) : Tendsto (fun xy : (ℝ × ℝ) => (1 - xy.1 * xy.2^2) * (1 - xy.1^2 * xy.2) * (S xy.1 xy.2)) (𝓝[A] ⟨1,1⟩) (𝓝 putnam_1999_b3_solution) := sorry diff --git a/lean4/src/putnam_1999_b5.lean b/lean4/src/putnam_1999_b5.lean index acd9a70e..0b1ee18e 100644 --- a/lean4/src/putnam_1999_b5.lean +++ b/lean4/src/putnam_1999_b5.lean @@ -8,7 +8,9 @@ noncomputable abbrev putnam_1999_b5_solution : ℕ → ℝ := sorry theorem putnam_1999_b5 (n : ℕ) (hn : n ≥ 3) -(theta : ℝ := 2 * Real.pi / n) -(A : Matrix (Fin n) (Fin n) ℝ := fun j k => Real.cos ((j.1 + 1) * theta + (k.1 + 1) * theta)) +(theta : ℝ) +(htheta : theta = 2 * Real.pi / n) +(A : Matrix (Fin n) (Fin n) ℝ) +(hA : A = fun j k => Real.cos ((j.1 + 1) * theta + (k.1 + 1) * theta)) : ((1 : Matrix (Fin n) (Fin n) ℝ) + A).det = putnam_1999_b5_solution n := sorry diff --git a/lean4/src/putnam_2000_b3.lean b/lean4/src/putnam_2000_b3.lean index f0737cce..afcaf11d 100644 --- a/lean4/src/putnam_2000_b3.lean +++ b/lean4/src/putnam_2000_b3.lean @@ -8,9 +8,11 @@ theorem putnam_2000_b3 (Npos : N > 0) (a : Fin (N + 1) → ℝ) (haN : a N ≠ 0) -(f : ℝ → ℝ := fun t ↦ ∑ j : Icc 1 N, a j * Real.sin (2 * Real.pi * j * t)) +(f : ℝ → ℝ) +(hf : f = fun t ↦ ∑ j : Icc 1 N, a j * Real.sin (2 * Real.pi * j * t)) (mult : (ℝ → ℝ) → ℝ → ℕ) (hmult : ∀ g : ℝ → ℝ, ∀ t : ℝ, (∃ c : ℕ, iteratedDeriv c g t ≠ 0) → (iteratedDeriv (mult g t) g t ≠ 0 ∧ ∀ k < (mult g t), iteratedDeriv k g t = 0)) -(M : ℕ → ℕ := fun k ↦ ∑' t : Ico (0 : ℝ) 1, mult (iteratedDeriv k f) t) +(M : ℕ → ℕ) +(hM : M = fun k ↦ ∑' t : Ico (0 : ℝ) 1, mult (iteratedDeriv k f) t) : ((∀ i j : ℕ, i ≤ j → M i ≤ M j) ∧ Tendsto M atTop (𝓝 (2 * N))) := sorry diff --git a/lean4/src/putnam_2001_a3.lean b/lean4/src/putnam_2001_a3.lean index 98bbad1f..53687774 100644 --- a/lean4/src/putnam_2001_a3.lean +++ b/lean4/src/putnam_2001_a3.lean @@ -6,7 +6,8 @@ open Topology Filter Polynomial Set abbrev putnam_2001_a3_solution : Set ℤ := sorry -- {m : ℤ | ∃ k : ℤ, k^2 = m ∨ 2*k^2 = m} theorem putnam_2001_a3 -(P : ℤ → Polynomial ℤ := fun m : ℤ => (Polynomial.X)^4 - (Polynomial.C (2*m + 4))*(Polynomial.X)^2 + Polynomial.C ((m - 2)^2)) +(P : ℤ → Polynomial ℤ) +(hP : P = fun m : ℤ => (Polynomial.X)^4 - (Polynomial.C (2*m + 4))*(Polynomial.X)^2 + Polynomial.C ((m - 2)^2)) : {m : ℤ | ∃ a : Polynomial ℤ, ∃ b : Polynomial ℤ, P m = a * b ∧ (∃ n ∈ Ici 1, a.coeff n ≠ 0) ∧ (∃ n ∈ Ici 1, b.coeff n ≠ 0)} = putnam_2001_a3_solution := sorry diff --git a/lean4/src/putnam_2002_a2.lean b/lean4/src/putnam_2002_a2.lean index 15fe366c..93b74de8 100644 --- a/lean4/src/putnam_2002_a2.lean +++ b/lean4/src/putnam_2002_a2.lean @@ -4,7 +4,9 @@ open BigOperators open Nat Metric theorem putnam_2002_a2 -(sphere : Set (EuclideanSpace ℝ (Fin 3)) := sphere 0 1) -(hemi : (EuclideanSpace ℝ (Fin 3)) → Set (EuclideanSpace ℝ (Fin 3)) := fun V ↦ {P : EuclideanSpace ℝ (Fin 3) | Matrix.dotProduct P V ≥ 0}) -: (∀ (S : Set (EuclideanSpace ℝ (Fin 3))), S ⊆ sphere ∧ S.encard = 5 → ∃ V : (EuclideanSpace ℝ (Fin 3)), V ≠ 0 ∧ (S ∩ hemi V).encard ≥ 4) := +(unit_sphere : Set (EuclideanSpace ℝ (Fin 3))) +(hsphere : unit_sphere = sphere 0 1) +(hemi : (EuclideanSpace ℝ (Fin 3)) → Set (EuclideanSpace ℝ (Fin 3))) +(hhemi : hemi = fun V ↦ {P : EuclideanSpace ℝ (Fin 3) | Matrix.dotProduct P V ≥ 0}) +: (∀ (S : Set (EuclideanSpace ℝ (Fin 3))), S ⊆ unit_sphere ∧ S.encard = 5 → ∃ V : (EuclideanSpace ℝ (Fin 3)), V ≠ 0 ∧ (S ∩ hemi V).encard ≥ 4) := sorry diff --git a/lean4/src/putnam_2002_b3.lean b/lean4/src/putnam_2002_b3.lean index fde5e8c6..a25089f0 100644 --- a/lean4/src/putnam_2002_b3.lean +++ b/lean4/src/putnam_2002_b3.lean @@ -4,7 +4,9 @@ open BigOperators open Nat Set Topology Filter theorem putnam_2002_b3 -(e : ℝ := Real.exp 1) -(f : ℤ → ℝ := fun n : ℤ => 1/e - (1 - 1/n)^n) +(e : ℝ) +(he : e = Real.exp 1) +(f : ℤ → ℝ) +(hf : f = fun n : ℤ => 1/e - (1 - 1/n)^n) : ∀ n : ℤ, n > 1 → 1/(2*n*e) < f n ∧ f n < 1/(n*e) := sorry diff --git a/lean4/src/putnam_2002_b6.lean b/lean4/src/putnam_2002_b6.lean index 698233ed..8e917665 100644 --- a/lean4/src/putnam_2002_b6.lean +++ b/lean4/src/putnam_2002_b6.lean @@ -6,7 +6,9 @@ open Nat Set Topology Filter Matrix MvPolynomial theorem putnam_2002_b6 (p : ℕ) (hp : Nat.Prime p) -(M : Matrix (Fin 3) (Fin 3) (MvPolynomial (Fin 3) ℤ) := fun r : Fin 3 => fun c : Fin 3 => (X c)^(p^(r : ℕ))) -(cong : ℕ → MvPolynomial (Fin 3) ℤ × MvPolynomial (Fin 3) ℤ → Prop := fun p : ℕ => fun (f, g) => ∀ n : Fin 3 →₀ ℕ, Int.ModEq p (f.coeff n) (g.coeff n)) +(M : Matrix (Fin 3) (Fin 3) (MvPolynomial (Fin 3) ℤ)) +(hM : M = fun (r c : Fin 3) => ((X c)^(p^(r : ℕ)) : MvPolynomial (Fin 3) ℤ)) +(cong : ℕ → MvPolynomial (Fin 3) ℤ × MvPolynomial (Fin 3) ℤ → Prop) +(hcong : cong = fun p : ℕ => fun (f, g) => ∀ n : Fin 3 →₀ ℕ, Int.ModEq p (f.coeff n) (g.coeff n)) : ∃ S : Finset (MvPolynomial (Fin 3) ℤ), cong p ((det M), (∏ s in S, s)) ∧ ∀ s ∈ S, (∃ a b c : ℤ, s = (C a)*(X 0) + (C b)*(X 1) + (C c)*(X 2)) := sorry diff --git a/lean4/src/putnam_2003_a5.lean b/lean4/src/putnam_2003_a5.lean index f2fb5253..91baf952 100644 --- a/lean4/src/putnam_2003_a5.lean +++ b/lean4/src/putnam_2003_a5.lean @@ -6,9 +6,11 @@ open MvPolynomial Set theorem putnam_2003_a5 (n : ℕ) (npos : n > 0) -(dyckpath : (m : ℕ) → Set ((Fin (2 * m)) → ℤ) := fun m ↦ {p : Fin (2 * m) → ℤ | +(dyckpath : (m : ℕ) → Set ((Fin (2 * m)) → ℤ)) +(hdyckpath : dyckpath = fun m ↦ {p : Fin (2 * m) → ℤ | range p ⊆ {-1, 1} ∧ ∑ k : Fin (2 * m), p k = 0 ∧ ∀ j : Fin (2 * m), ∑ k : Fin (2 * m), ite (k ≤ j) (p k) 0 ≥ 0}) -(noevenreturn : (m : ℕ) → Set ((Fin (2 * m)) → ℤ) := fun m ↦ {p : Fin (2 * m) → ℤ | +(noevenreturn : (m : ℕ) → Set ((Fin (2 * m)) → ℤ)) +(hnoevenreturn : noevenreturn = fun m ↦ {p : Fin (2 * m) → ℤ | ¬∃ i j : Fin (2 * m), i < j ∧ p i = 1 ∧ (∀ k ∈ Ioc i j, p i = -1) ∧ Even (j.1 - i.1) ∧ ∑ k : Fin (2 * m), ite (k ≤ j) (p k) 0 = 0}) : (∃ f : ((Fin (2 * n)) → ℤ) → (Fin (2 * (n - 1)) → ℤ), ∀ y ∈ dyckpath (n - 1), ∃! x, x ∈ dyckpath n ∩ noevenreturn n ∧ f x = y) := sorry diff --git a/lean4/src/putnam_2004_a5.lean b/lean4/src/putnam_2004_a5.lean index 54e01783..93581873 100644 --- a/lean4/src/putnam_2004_a5.lean +++ b/lean4/src/putnam_2004_a5.lean @@ -6,9 +6,12 @@ open Nat Topology Filter theorem putnam_2004_a5 (m n : ℕ) (mnpos : Inhabited (Fin m × Fin n)) -(adj : (Fin m × Fin n) → (Fin m × Fin n) → Prop := fun (⟨a, _⟩, ⟨b, _⟩) (⟨c, _⟩, ⟨d, _⟩) ↦ a = c ∧ Nat.dist b d = 1 ∨ b = d ∧ Nat.dist a c = 1) -(connected : (Fin m × Fin n → Prop) → (Fin m × Fin n) → (Fin m × Fin n) → Prop := fun C P Q ↦ ∃ (S : List (Fin m × Fin n)) (hS : S ≠ []), +(adj : (Fin m × Fin n) → (Fin m × Fin n) → Prop) +(connected : (Fin m × Fin n → Prop) → (Fin m × Fin n) → (Fin m × Fin n) → Prop) +(cmr : (Fin m × Fin n → Prop) → ℕ) +(hadj : adj = fun (⟨a, _⟩, ⟨b, _⟩) (⟨c, _⟩, ⟨d, _⟩) ↦ a = c ∧ Nat.dist b d = 1 ∨ b = d ∧ Nat.dist a c = 1) +(hconnected : connected = fun C P Q ↦ ∃ (S : List (Fin m × Fin n)) (hS : S ≠ []), S.head hS = P ∧ S.getLast hS = Q ∧ (∃ p : Prop, ∀ i ∈ Finset.range S.length, C S[i]! = p) ∧ (∀ i ∈ Finset.range (S.length - 1), adj S[i]! S[i+1]!)) -(cmr : (Fin m × Fin n → Prop) → ℕ := fun C ↦ {R : Set (Fin m × Fin n) | ∃ P ∈ R, ∀ Q, Q ∈ R ↔ connected C P Q}.ncard) +(hcmr : cmr = fun C ↦ {R : Set (Fin m × Fin n) | ∃ P ∈ R, ∀ Q, Q ∈ R ↔ connected C P Q}.ncard) : (∑ C : Fin m × Fin n → Prop, cmr C > 2 ^ (m * n) * (m * n / (8 : ℚ))) := sorry diff --git a/lean4/src/putnam_2004_b4.lean b/lean4/src/putnam_2004_b4.lean index 8cc3351a..84e5d6ad 100644 --- a/lean4/src/putnam_2004_b4.lean +++ b/lean4/src/putnam_2004_b4.lean @@ -8,8 +8,8 @@ abbrev putnam_2004_b4_solution : ℕ → ℂ → ℂ := sorry theorem putnam_2004_b4 (n : ℕ) (nge2 : n ≥ 2) -(Rk : ℕ → ℂ → ℂ := fun k Q ↦ k + Complex.exp (Complex.I * 2 * Real.pi / n) * (Q - k)) -(R : ℕ → ℂ → ℂ) +(R Rk : ℕ → ℂ → ℂ) (hR : R 0 = id ∧ ∀ k : ℕ, R (k + 1) = Rk (k + 1) ∘ R k) +(hRk : Rk = fun (k : ℕ) (Q : ℂ) ↦ k + Complex.exp (Complex.I * 2 * Real.pi / n) * (Q - k)) : (R n = putnam_2004_b4_solution n) := sorry diff --git a/lean4/src/putnam_2005_a2.lean b/lean4/src/putnam_2005_a2.lean index ebeb5a66..681109e9 100644 --- a/lean4/src/putnam_2005_a2.lean +++ b/lean4/src/putnam_2005_a2.lean @@ -9,8 +9,11 @@ abbrev putnam_2005_a2_solution : ℕ → ℕ := sorry theorem putnam_2005_a2 (n : ℕ) (npos : n > 0) -(S : Set (ℤ × ℤ) := Set.prod (Icc 1 n) (Icc 1 3)) -(unit : ℤ × ℤ → ℤ × ℤ → Prop := fun (a, b) (c, d) ↦ a = c ∧ |d - b| = 1 ∨ b = d ∧ |c - a| = 1) -(rooktour : (ℕ → ℤ × ℤ) → Prop := fun p ↦ (∀ P ∈ S, ∃! i, i ∈ Icc 1 (3 * n) ∧ p i = P) ∧ (∀ i ∈ Icc 1 (3 * n - 1), unit (p i) (p (i + 1))) ∧ p 0 = 0 ∧ ∀ i > 3 * n, p i = 0) +(S : Set (ℤ × ℤ)) +(unit : ℤ × ℤ → ℤ × ℤ → Prop) +(rooktour : (ℕ → ℤ × ℤ) → Prop) +(hS : S = prod (Icc 1 (n : ℤ)) (Icc 1 3)) +(hunit : unit = fun (a, b) (c, d) ↦ a = c ∧ |d - b| = 1 ∨ b = d ∧ |c - a| = 1) +(hrooktour : rooktour = fun p ↦ (∀ P ∈ S, ∃! i, i ∈ Icc 1 (3 * n) ∧ p i = P) ∧ (∀ i ∈ Icc 1 (3 * n - 1), unit (p i) (p (i + 1))) ∧ p 0 = 0 ∧ ∀ i > 3 * n, p i = 0) : ({p : ℕ → ℤ × ℤ | rooktour p ∧ p 1 = (1, 1) ∧ p (3 * n) = ((n : ℤ), 1)}.encard = putnam_2005_a2_solution n) := sorry diff --git a/lean4/src/putnam_2006_b1.lean b/lean4/src/putnam_2006_b1.lean index 9cd598cf..83933397 100644 --- a/lean4/src/putnam_2006_b1.lean +++ b/lean4/src/putnam_2006_b1.lean @@ -4,7 +4,9 @@ open BigOperators noncomputable abbrev putnam_2006_b1_solution : ℝ := sorry -- 3 * Real.sqrt 3 / 2 theorem putnam_2006_b1 -(curve : Set (ℝ × ℝ) := {(x, y) | x ^ 3 + 3 * x * y + y ^ 3 = 1}) -(equilateral : Set (ℝ × ℝ) → Prop := fun S ↦ S.encard = 3 ∧ ∃ d : ℝ, ∀ P ∈ S, ∀ Q ∈ S, P ≠ Q → Real.sqrt ((P.1 - Q.1)^2 + (P.2 - Q.2)^2) = d) +(curve : Set (ℝ × ℝ)) +(hcurve : curve = {(x, y) | x ^ 3 + 3 * x * y + y ^ 3 = 1}) +(equilateral : Set (ℝ × ℝ) → Prop) +(hequilateral : equilateral = fun S ↦ S.encard = 3 ∧ ∃ d : ℝ, ∀ P ∈ S, ∀ Q ∈ S, P ≠ Q → Real.sqrt ((P.1 - Q.1)^2 + (P.2 - Q.2)^2) = d) : ((∃! S : Set (ℝ × ℝ), S ⊆ curve ∧ equilateral S) ∧ (∃ S : Set (ℝ × ℝ), S ⊆ curve ∧ equilateral S ∧ (MeasureTheory.volume (convexHull ℝ S)).toReal = putnam_2006_b1_solution)) := sorry diff --git a/lean4/src/putnam_2006_b4.lean b/lean4/src/putnam_2006_b4.lean index b2cadc13..54d58f97 100644 --- a/lean4/src/putnam_2006_b4.lean +++ b/lean4/src/putnam_2006_b4.lean @@ -4,12 +4,11 @@ open BigOperators noncomputable abbrev putnam_2006_b4_solution : ℕ → ℕ := sorry -- fun k ↦ 2 ^ k theorem putnam_2006_b4 -(n : ℕ) +(n k max : ℕ) (npos : n > 0) -(k : ℕ) (hk : k ≤ n) -(Z : Set (Fin n → ℝ) := {P : Fin n → ℝ | ∀ j : Fin n, P j = 0 ∨ P j = 1}) -(max : ℕ) +(Z : Set (Fin n → ℝ)) +(hZ : Z = {P : Fin n → ℝ | ∀ j : Fin n, P j = 0 ∨ P j = 1}) (hmaxeq : ∃ V : Subspace ℝ (Fin n → ℝ), Module.rank V = k ∧ (Z ∩ V).ncard = max) (hmaxub : ∀ V : Subspace ℝ (Fin n → ℝ), Module.rank V = k → (Z ∩ V).ncard ≤ max) : (max = putnam_2006_b4_solution k) := diff --git a/lean4/src/putnam_2006_b5.lean b/lean4/src/putnam_2006_b5.lean index be77c47c..54ba3f6b 100644 --- a/lean4/src/putnam_2006_b5.lean +++ b/lean4/src/putnam_2006_b5.lean @@ -6,8 +6,10 @@ open Set noncomputable abbrev putnam_2006_b5_solution : ℝ := sorry -- 1 / 16 theorem putnam_2006_b5 -(I : (ℝ → ℝ) → ℝ := fun f ↦ ∫ x in (0)..1, x ^ 2 * (f x)) -(J : (ℝ → ℝ) → ℝ := fun f ↦ ∫ x in (0)..1, x * (f x) ^ 2) +(I : (ℝ → ℝ) → ℝ) +(J : (ℝ → ℝ) → ℝ) +(hI : I = fun f ↦ ∫ x in (0)..1, x ^ 2 * (f x)) +(hJ : J = fun f ↦ ∫ x in (0)..1, x * (f x) ^ 2) (max : ℝ) (heqmax : ∃ f : ℝ → ℝ, ContinuousOn f (Icc 0 1) ∧ I f - J f = max) (hmaxub : ∀ f : ℝ → ℝ, ContinuousOn f (Icc 0 1) → I f - J f ≤ max) diff --git a/lean4/src/putnam_2007_a3.lean b/lean4/src/putnam_2007_a3.lean index 47086632..2dd7fc02 100644 --- a/lean4/src/putnam_2007_a3.lean +++ b/lean4/src/putnam_2007_a3.lean @@ -8,7 +8,9 @@ abbrev putnam_2007_a3_solution : ℕ → ℚ := sorry theorem putnam_2007_a3 (k : ℕ) (kpos : k > 0) -(perms : Set (Fin (3 * k + 1) → ℤ) := {f : Fin (3 * k + 1) → ℤ | ∀ y ∈ Icc 1 (3 * k + 1), ∃! x : Fin (3 * k + 1), f x = y}) -(goodperms : Set (Fin (3 * k + 1) → ℤ) := {f ∈ perms | ¬∃ j : Fin (3 * k + 1), 3 ∣ ∑ i : Fin (3 * k + 1), ite (i ≤ j) (f i) 0}) +(perms : Set (Fin (3 * k + 1) → ℤ)) +(goodperms : Set (Fin (3 * k + 1) → ℤ)) +(hgoodperms : goodperms = {f ∈ perms | ¬∃ j : Fin (3 * k + 1), 3 ∣ ∑ i : Fin (3 * k + 1), ite (i ≤ j) (f i) 0}) +(hperms : perms = {f : Fin (3 * k + 1) → ℤ | ∀ y ∈ Icc 1 (3 * k + 1), ∃! x : Fin (3 * k + 1), f x = y}) : (goodperms.ncard = perms.ncard * (putnam_2007_a3_solution k)) := sorry diff --git a/lean4/src/putnam_2007_a4.lean b/lean4/src/putnam_2007_a4.lean index adba5654..72167b0a 100644 --- a/lean4/src/putnam_2007_a4.lean +++ b/lean4/src/putnam_2007_a4.lean @@ -7,7 +7,8 @@ abbrev putnam_2007_a4_solution : Set (Polynomial ℝ) := sorry -- {f : Polynomial ℝ | ∃ d : ℕ, ∃ c ≥ (1 : ℤ) - d, ∀ n : ℝ, f.eval n = (1 / 9) * ((10 ^ c) * (9 * n + 1) ^ d - 1)} theorem putnam_2007_a4 (S : Set (Polynomial ℝ)) -(repunit : ℝ → Prop := fun x ↦ x > 0 ∧ x = floor x ∧ ∀ d ∈ (digits 10 (floor x)), d = 1) +(repunit : ℝ → Prop) +(hrepunit : repunit = fun (x : ℝ) ↦ x > 0 ∧ x = floor x ∧ ∀ d ∈ (digits 10 (floor x)), d = 1) (hS : ∀ f : Polynomial ℝ, f ∈ S ↔ (∀ n : ℝ, repunit n → repunit (f.eval n))) : (S = putnam_2007_a4_solution) := sorry diff --git a/lean4/src/putnam_2007_b6.lean b/lean4/src/putnam_2007_b6.lean index cf31289b..a87767a6 100644 --- a/lean4/src/putnam_2007_b6.lean +++ b/lean4/src/putnam_2007_b6.lean @@ -4,6 +4,7 @@ open BigOperators open Set Nat Function theorem putnam_2007_b6 -(f : ℕ → ℕ := fun n ↦ {M : Multiset ℕ | M.sum = (n)! ∧ ∀ m ∈ M, ∃ k ∈ Icc 1 n, m = (k)!}.ncard) +(f : ℕ → ℕ) +(hf : f = fun n ↦ {M : Multiset ℕ | M.sum = (n)! ∧ ∀ m ∈ M, ∃ k ∈ Icc 1 n, m = (k)!}.ncard) : (∃ C : ℝ, ∀ n : ℕ, n ≥ 2 → n ^ (n ^ 2 / 2 - C * n) * Real.exp (-(n ^ 2) / 4) ≤ f n ∧ f n ≤ n ^ (n ^ 2 / 2 + C * n) * Real.exp (-(n ^ 2) / 4)) := sorry diff --git a/lean4/src/putnam_2008_a3.lean b/lean4/src/putnam_2008_a3.lean index 4a738843..43c11554 100644 --- a/lean4/src/putnam_2008_a3.lean +++ b/lean4/src/putnam_2008_a3.lean @@ -6,9 +6,12 @@ theorem putnam_2008_a3 (npos : n > 0) (a : Fin n → ℕ) (apos : ∀ i : Fin n, a i > 0) -(cont : (Fin n → ℕ) → Prop := fun s ↦ ∃ j k : Fin n, j < k ∧ ¬(s j ∣ s k)) -(init : (ℕ → Fin n → ℕ) → Prop := fun P ↦ P 0 = a) -(trans : (ℕ → Fin n → ℕ) → Prop := fun P ↦ ∀ t : ℕ, cont (P t) → +(cont : (Fin n → ℕ) → Prop) +(hcont : cont = fun s ↦ ∃ j k : Fin n, j < k ∧ ¬(s j ∣ s k)) +(init : (ℕ → Fin n → ℕ) → Prop) +(hinit : init = fun P ↦ P 0 = a) +(trans : (ℕ → Fin n → ℕ) → Prop) +(htrans : trans = fun P ↦ ∀ t : ℕ, cont (P t) → ∃ j k : Fin n, j < k ∧ ¬(P t j ∣ P t k) ∧ P (t + 1) j = Nat.gcd (P t j) (P t k) ∧ P (t + 1) k = Nat.lcm (P t j) (P t k) ∧ ∀ i : Fin n, i ≠ j → i ≠ k → P (t + 1) i = P t i) : (∃ f : Fin n → ℕ, ∀ P : ℕ → Fin n → ℕ, init P → trans P → ∃ t : ℕ, ¬cont (P t) ∧ P t = f) := diff --git a/lean4/src/putnam_2008_b3.lean b/lean4/src/putnam_2008_b3.lean index fc1acfbb..58a03094 100644 --- a/lean4/src/putnam_2008_b3.lean +++ b/lean4/src/putnam_2008_b3.lean @@ -6,7 +6,9 @@ open Filter Topology Set Nat noncomputable abbrev putnam_2008_b3_solution : ℝ := sorry -- Real.sqrt 2 / 2 theorem putnam_2008_b3 -(hypercube : Set (EuclideanSpace ℝ (Fin 4)) := {P : Fin 4 → ℝ | ∀ i : Fin 4, |P i| ≤ 1 / 2}) -(contains : ℝ → (EuclideanSpace ℝ (Fin 4)) → (EuclideanSpace ℝ (Fin 4)) → (EuclideanSpace ℝ (Fin 4)) → Prop := fun r O P Q ↦ ∀ s t : ℝ, (s • P + t • Q ≠ 0 ∧ dist 0 (s • P + t • Q) = r) → O + s • P + t • Q ∈ hypercube) +(hypercube : Set (EuclideanSpace ℝ (Fin 4))) +(hhypercube : hypercube = {P : Fin 4 → ℝ | ∀ i : Fin 4, |P i| ≤ 1 / 2}) +(contains : ℝ → (EuclideanSpace ℝ (Fin 4)) → (EuclideanSpace ℝ (Fin 4)) → (EuclideanSpace ℝ (Fin 4)) → Prop) +(hcontains : contains = fun r O P Q ↦ ∀ s t : ℝ, (s • P + t • Q ≠ 0 ∧ dist 0 (s • P + t • Q) = r) → O + s • P + t • Q ∈ hypercube) : (∃ O P Q, contains putnam_2008_b3_solution O P Q) ∧ (∀ r > putnam_2008_b3_solution, ¬∃ O P Q, contains r O P Q) := sorry diff --git a/lean4/src/putnam_2008_b5.lean b/lean4/src/putnam_2008_b5.lean index 93622412..4b97404b 100644 --- a/lean4/src/putnam_2008_b5.lean +++ b/lean4/src/putnam_2008_b5.lean @@ -6,7 +6,7 @@ open Filter Topology Set Nat abbrev putnam_2008_b5_solution : Set (ℝ → ℝ) := sorry -- {fun (x : ℝ) => x + n | n : ℤ} ∪ {fun (x : ℝ) => -x + n | n : ℤ} theorem putnam_2008_b5 -(fqsat : (ℝ → ℝ) → ℚ → Prop := fun f q => ContDiff ℝ 1 f ∧ (∃ p : ℚ, p = f q ∧ p.den = q.den)) -(fsat : (ℝ → ℝ) → Prop := fun f => ∀ q : ℚ, fqsat f q) -: ∀ f : (ℝ → ℝ), fsat f ↔ f ∈ putnam_2008_b5_solution := +(fqsat : (ℝ → ℝ) → ℚ → Prop) +(hfqsat : fqsat = fun (f : ℝ → ℝ) (q : ℚ) => ContDiff ℝ 1 f ∧ (∃ p : ℚ, p = f q ∧ p.den = q.den)) +: ∀ f : (ℝ → ℝ), (∀ q : ℚ, fqsat f q) ↔ f ∈ putnam_2008_b5_solution := sorry diff --git a/lean4/src/putnam_2009_b1.lean b/lean4/src/putnam_2009_b1.lean index 6f778b4a..4e062a81 100644 --- a/lean4/src/putnam_2009_b1.lean +++ b/lean4/src/putnam_2009_b1.lean @@ -4,10 +4,10 @@ open BigOperators open Topology MvPolynomial Filter Set theorem putnam_2009_b1 -(isquotprodprimefact : ℚ → Prop := -fun q => (∃ (k m : ℕ) (a : Fin k → ℕ) (b : Fin m → ℕ), +(isquotprodprimefact : ℚ → Prop) +(hisquotprodprimefact : isquotprodprimefact = +fun (q : ℚ) => (∃ (k m : ℕ) (a : Fin k → ℕ) (b : Fin m → ℕ), (∀ i : Fin k, Nat.Prime (a i)) ∧ (∀ j : Fin m, Nat.Prime (b j)) -∧ (q = (∏ i : Fin k, Nat.factorial (a i))/(∏ j : Fin m, Nat.factorial (b j))) -)) +∧ (q = (∏ i : Fin k, Nat.factorial (a i))/(∏ j : Fin m, Nat.factorial (b j))))) : ∀ q : ℚ, q > 0 → isquotprodprimefact q := sorry diff --git a/lean4/src/putnam_2009_b3.lean b/lean4/src/putnam_2009_b3.lean index e72a769f..0a61344b 100644 --- a/lean4/src/putnam_2009_b3.lean +++ b/lean4/src/putnam_2009_b3.lean @@ -6,7 +6,9 @@ open Topology MvPolynomial Filter Set abbrev putnam_2009_b3_solution : Set ℤ := sorry -- {n : ℤ | ∃ k ≥ 1, n = 2 ^ k - 1} theorem putnam_2009_b3 -(mediocre : ℤ → Set ℤ → Prop := fun n S ↦ (S ⊆ Icc 1 n) ∧ ∀ a ∈ S, ∀ b ∈ S, 2 ∣ a + b → (a + b) / 2 ∈ S) -(A : ℤ → ℤ := fun n ↦ {S : Set ℤ | mediocre n S}.ncard) +(mediocre : ℤ → Set ℤ → Prop) +(hmediocre : mediocre = fun n S ↦ (S ⊆ Icc 1 n) ∧ ∀ a ∈ S, ∀ b ∈ S, 2 ∣ a + b → (a + b) / 2 ∈ S) +(A : ℤ → ℤ) +(hA : A = fun n ↦ ({S : Set ℤ | mediocre n S}.ncard : ℤ)) : ({n : ℤ | n > 0 ∧ A (n + 2) - 2 * A (n + 1) + A n = 1} = putnam_2009_b3_solution) := sorry diff --git a/lean4/src/putnam_2009_b4.lean b/lean4/src/putnam_2009_b4.lean index 64009b17..c799774f 100644 --- a/lean4/src/putnam_2009_b4.lean +++ b/lean4/src/putnam_2009_b4.lean @@ -6,7 +6,8 @@ open Topology MvPolynomial Filter Set Metric abbrev putnam_2009_b4_solution : ℕ := sorry -- 2020050 theorem putnam_2009_b4 -(balanced : MvPolynomial (Fin 2) ℝ → Prop := fun P ↦ ∀ r > 0, (∫ x in Metric.sphere (0 : EuclideanSpace ℝ (Fin 2)) r, MvPolynomial.eval x P) / (2 * Real.pi * r) = 0) +(balanced : MvPolynomial (Fin 2) ℝ → Prop) +(hbalanced : balanced = fun P ↦ ∀ r > 0, (∫ x in Metric.sphere (0 : EuclideanSpace ℝ (Fin 2)) r, MvPolynomial.eval x P) / (2 * Real.pi * r) = 0) (V : Set (MvPolynomial (Fin 2) ℝ)) [AddCommGroup V] [Module ℝ V] (hV : ∀ P : MvPolynomial (Fin 2) ℝ, P ∈ V ↔ balanced P ∧ P.totalDegree ≤ 2009) : (Module.rank V = putnam_2009_b4_solution) := diff --git a/lean4/src/putnam_2010_b3.lean b/lean4/src/putnam_2010_b3.lean index 9de35f62..75bb5754 100644 --- a/lean4/src/putnam_2010_b3.lean +++ b/lean4/src/putnam_2010_b3.lean @@ -8,7 +8,8 @@ abbrev putnam_2010_b3_solution : Set ℕ := sorry theorem putnam_2010_b3 (n : ℕ) (npos : n > 0) -(trans : (ℕ → Fin 2010 → ℕ) → ℕ → Prop := fun P T ↦ ∀ t : ℕ, t < T → +(trans : (ℕ → Fin 2010 → ℕ) → ℕ → Prop) +(htrans : trans = fun P T ↦ ∀ t : ℕ, t < T → ∃ i j : Fin 2010, i ≠ j ∧ P t i ≥ i.1 + 1 ∧ P (t + 1) i = P t i - (i.1 + 1) ∧ P (t + 1) j = P t j + (i.1 + 1) ∧ ∀ k : Fin 2010, k ≠ i → k ≠ j → P (t + 1) k = P t k) : ((∀ B : Fin 2010 → ℕ, ∑ i : Fin 2010, B i = 2010 * n → ∃ (P : ℕ → Fin 2010 → ℕ) (T : ℕ), P 0 = B ∧ trans P T ∧ ∀ i : Fin 2010, P T i = n) ↔ n ∈ putnam_2010_b3_solution) := sorry diff --git a/lean4/src/putnam_2011_a1.lean b/lean4/src/putnam_2011_a1.lean index 842fba28..1038aef5 100644 --- a/lean4/src/putnam_2011_a1.lean +++ b/lean4/src/putnam_2011_a1.lean @@ -4,7 +4,8 @@ open BigOperators abbrev putnam_2011_a1_solution : ℕ := sorry -- 10053 theorem putnam_2011_a1 -(isspiral : List (Fin 2 → ℤ) → Prop := (fun P : List (Fin 2 → ℤ) => P.length ≥ 3 ∧ P[0]! = 0 ∧ +(isspiral : List (Fin 2 → ℤ) → Prop) +(hisspiral : isspiral = (fun P : List (Fin 2 → ℤ) => P.length ≥ 3 ∧ P[0]! = 0 ∧ (∃ l : Fin (P.length - 1) → ℕ, l > 0 ∧ StrictMono l ∧ (∀ i : Fin (P.length - 1), (i.1 % 4 = 0 → (P[i] 0 + l i = P[i.1 + 1]! 0 ∧ P[i] 1 = P[i.1 + 1]! 1)) ∧ (i.1 % 4 = 1 → (P[i] 0 = P[i.1 + 1]! 0 ∧ P[i] 1 + l i = P[i.1 + 1]! 1)) ∧ diff --git a/lean4/src/putnam_2011_a5.lean b/lean4/src/putnam_2011_a5.lean index 23c1be2f..8cbfc691 100644 --- a/lean4/src/putnam_2011_a5.lean +++ b/lean4/src/putnam_2011_a5.lean @@ -8,7 +8,8 @@ theorem putnam_2011_a5 (g : ℝ → ℝ) (vec : ℝ → ℝ → (Fin 2 → ℝ)) (Fgrad : (Fin 2 → ℝ) → (Fin 2 → ℝ)) -(parallel : (Fin 2 → ℝ) → (Fin 2 → ℝ) → Prop := (fun u v : Fin 2 → ℝ => ∃ c : ℝ, u = c • v)) +(parallel : (Fin 2 → ℝ) → (Fin 2 → ℝ) → Prop) +(hparallel : parallel = (fun u v : Fin 2 → ℝ => ∃ c : ℝ, u = c • v)) (Fgdiff : ContDiff ℝ 2 F ∧ ContDiff ℝ 2 g) (prop1 : ∀ uu : Fin 2 → ℝ, uu 0 = uu 1 → F uu = 0) (prop2 : ∀ x : ℝ, g x > 0 ∧ x ^ 2 * g x ≤ 1) diff --git a/lean4/src/putnam_2011_a6.lean b/lean4/src/putnam_2011_a6.lean index 0830a9ac..aea65c7b 100644 --- a/lean4/src/putnam_2011_a6.lean +++ b/lean4/src/putnam_2011_a6.lean @@ -8,7 +8,8 @@ theorem putnam_2011_a6 (n : ℕ) (gset : Set G) (k : ℕ) -(mgprob : ℕ → G → ℝ := (fun (m : ℕ) (x : G) => {f : Fin m → gset | (∏ i : Fin m, (f i).1) = x}.ncard / k ^ m)) +(mgprob : ℕ → G → ℝ) +(hmgprob : mgprob = (fun (m : ℕ) (x : G) => ({f : Fin m → gset | (∏ i : Fin m, (f i).1) = x}.ncard : ℝ) / k ^ m)) (hn : n = (Fintype.elems : Finset G).card) (hk : gset.encard = k) (hgsetprop : k < n) diff --git a/lean4/src/putnam_2011_b4.lean b/lean4/src/putnam_2011_b4.lean index beb2c391..5e70fb7a 100644 --- a/lean4/src/putnam_2011_b4.lean +++ b/lean4/src/putnam_2011_b4.lean @@ -5,7 +5,9 @@ open Topology Filter Matrix theorem putnam_2011_b4 (games : Fin 2011 → Fin 2011 → Bool) -(T : Matrix (Fin 2011) (Fin 2011) ℂ := (fun p1 p2 : Fin 2011 => {g : Fin 2011 | games g p1 = games g p2}.ncard)) -(W : Matrix (Fin 2011) (Fin 2011) ℂ := (fun p1 p2 : Fin 2011 => {g : Fin 2011 | games g p1 ∧ !games g p2}.ncard - {g : Fin 2011 | !games g p1 ∧ games g p2}.ncard)) +(T : Matrix (Fin 2011) (Fin 2011) ℂ) +(hT : T = (fun p1 p2 : Fin 2011 => ({g : Fin 2011 | games g p1 = games g p2}.ncard : ℂ))) +(W : Matrix (Fin 2011) (Fin 2011) ℂ) +(hW : W = (fun p1 p2 : Fin 2011 => ({g : Fin 2011 | games g p1 ∧ !games g p2}.ncard - {g : Fin 2011 | !games g p1 ∧ games g p2}.ncard : ℂ))) : ∃ n : ℕ, (T + Complex.I • W).det = n ∧ (2 ^ 2010) ∣ n := sorry diff --git a/lean4/src/putnam_2012_a3.lean b/lean4/src/putnam_2012_a3.lean index 804124be..6977177e 100644 --- a/lean4/src/putnam_2012_a3.lean +++ b/lean4/src/putnam_2012_a3.lean @@ -7,9 +7,11 @@ open Matrix Function noncomputable abbrev putnam_2012_a3_solution : ℝ → ℝ := sorry -- fun x : ℝ => Real.sqrt (1 - x^2) theorem putnam_2012_a3 -(S : Set ℝ := Set.Icc (-1 : ℝ) 1) -(hf : (ℝ → ℝ) → Prop := fun f : ℝ → ℝ => ContinuousOn f S ∧ +(S : Set ℝ) +(hS : S = Set.Icc (-1 : ℝ) 1) +(fsat : (ℝ → ℝ) → Prop) +(hfsat : fsat = fun f : ℝ → ℝ => ContinuousOn f S ∧ (∀ x ∈ S, f x = ((2 - x^2)/2)*f (x^2/(2 - x^2))) ∧ f 0 = 1 ∧ (∃ y : ℝ, leftLim (fun x : ℝ => (f x)/Real.sqrt (1 - x)) 1 = y)) -: hf putnam_2012_a3_solution ∧ ∀ f : ℝ → ℝ, hf f → ∀ x ∈ S, f x = putnam_2012_a3_solution x := +: fsat putnam_2012_a3_solution ∧ ∀ f : ℝ → ℝ, fsat f → ∀ x ∈ S, f x = putnam_2012_a3_solution x := sorry diff --git a/lean4/src/putnam_2012_a6.lean b/lean4/src/putnam_2012_a6.lean index e9b6f864..e800cafa 100644 --- a/lean4/src/putnam_2012_a6.lean +++ b/lean4/src/putnam_2012_a6.lean @@ -7,6 +7,7 @@ open Matrix Function abbrev putnam_2012_a6_solution : Prop := sorry -- True theorem putnam_2012_a6 -(p : ((ℝ × ℝ) → ℝ) → Prop := fun f ↦ Continuous f ∧ ∀ x1 x2 y1 y2 : ℝ, x2 > x1 → y2 > y1 → (x2 - x1) * (y2 - y1) = 1 → ∫ x in x1..x2, ∫ y in y1..y2, f (x, y) = 0) +(p : ((ℝ × ℝ) → ℝ) → Prop) +(hp : p = fun f ↦ Continuous f ∧ ∀ x1 x2 y1 y2 : ℝ, x2 > x1 → y2 > y1 → (x2 - x1) * (y2 - y1) = 1 → ∫ x in x1..x2, ∫ y in y1..y2, f (x, y) = 0) : ((∀ f : (ℝ × ℝ) → ℝ, ∀ x y : ℝ, p f → f (x, y) = 0) ↔ putnam_2012_a6_solution) := sorry diff --git a/lean4/src/putnam_2012_b1.lean b/lean4/src/putnam_2012_b1.lean index e22ac2ed..3dd324b6 100644 --- a/lean4/src/putnam_2012_b1.lean +++ b/lean4/src/putnam_2012_b1.lean @@ -4,15 +4,16 @@ open BigOperators open Matrix Function Real theorem putnam_2012_b1 -(nneg : Set ℝ := Set.Ici 0) -(S : Set (nneg → ℝ)) -(rngS : ∀ f ∈ S, ∀ x : nneg, f x ∈ nneg) -(f1 : nneg → ℝ := fun x ↦ exp x - 1) -(f2 : nneg → ℝ := fun x ↦ Real.log (x + 1)) -(hf1 : f1 ∈ S) -(hf2 : f2 ∈ S) +(S : Set (Set.Ici (0 : ℝ) → ℝ)) +(rngS : ∀ f ∈ S, ∀ x : Set.Ici (0 : ℝ), f x ∈ Set.Ici (0 : ℝ)) +(f1 : Set.Ici (0 : ℝ) → ℝ) +(hf1 : f1 = fun (x : Set.Ici (0 : ℝ)) ↦ exp x - 1) +(f2 : Set.Ici (0 : ℝ) → ℝ ) +(hf2 : f2 = fun (x : Set.Ici (0 : ℝ)) ↦ Real.log (x + 1)) +(hf1mem : f1 ∈ S) +(hf2mem : f2 ∈ S) (hsum : ∀ f ∈ S, ∀ g ∈ S, (fun x ↦ (f x) + (g x)) ∈ S) -(hcomp : ∀ f ∈ S, ∀ g ∈ S, ∀ gnneg : nneg → nneg, ((∀ x : nneg, g x = gnneg x) → (fun x ↦ f (gnneg x)) ∈ S)) -(hdiff : ∀ f ∈ S, ∀ g ∈ S, (∀ x : nneg, f x ≥ g x) → (fun x ↦ (f x) - (g x)) ∈ S) +(hcomp : ∀ f ∈ S, ∀ g ∈ S, ∀ gnneg : Set.Ici (0 : ℝ) → Set.Ici (0 : ℝ), ((∀ x : Set.Ici (0 : ℝ), g x = gnneg x) → (fun x ↦ f (gnneg x)) ∈ S)) +(hdiff : ∀ f ∈ S, ∀ g ∈ S, (∀ x : Set.Ici (0 : ℝ), f x ≥ g x) → (fun x ↦ (f x) - (g x)) ∈ S) : (∀ f ∈ S, ∀ g ∈ S, (fun x ↦ (f x) * (g x)) ∈ S) := sorry diff --git a/lean4/src/putnam_2012_b3.lean b/lean4/src/putnam_2012_b3.lean index ca487a31..60e25578 100644 --- a/lean4/src/putnam_2012_b3.lean +++ b/lean4/src/putnam_2012_b3.lean @@ -6,9 +6,11 @@ open Matrix Function Real abbrev putnam_2012_b3_solution : Prop := sorry -- True theorem putnam_2012_b3 -(nmatchupsgames : (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → Prop := (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) => ∀ d : Fin (2 * n - 1), ∀ t : Fin (2 * n), matchups d t ≠ t ∧ matchups d (matchups d t) = t)) -(nmatchupsall : (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → Prop := (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) => ∀ t1 t2 : Fin (2 * n), t1 ≠ t2 → (∃ d : Fin (2 * n - 1), matchups d t1 = t2))) -(nmatchupswins : (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → (Fin (2 * n - 1) → (Fin (2 * n) → Bool)) → Prop := (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) (wins : Fin (2 * n - 1) → (Fin (2 * n) → Bool)) => ∀ d : Fin (2 * n - 1), ∀ t : Fin (2 * n), wins d t = !(wins d (matchups d t)))) -(nmatchupswinschoices : (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → (Fin (2 * n - 1) → (Fin (2 * n) → Bool)) → Prop := (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) (wins : Fin (2 * n - 1) → (Fin (2 * n) → Bool)) => ∃ choices : Fin (2 * n - 1) → Fin (2 * n), (∀ d : Fin (2 * n - 1), wins d (choices d)) ∧ Function.Injective choices)) +(nmatchupsgames nmatchupsall : (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → Prop) +(hnmatchupsall : nmatchupsall = (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) => ∀ t1 t2 : Fin (2 * n), t1 ≠ t2 → (∃ d : Fin (2 * n - 1), matchups d t1 = t2))) +(hnmatchupsgames : nmatchupsgames = (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) => ∀ d : Fin (2 * n - 1), ∀ t : Fin (2 * n), matchups d t ≠ t ∧ matchups d (matchups d t) = t)) +(nmatchupswins nmatchupswinschoices: (n : ℕ) → (Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) → (Fin (2 * n - 1) → (Fin (2 * n) → Bool)) → Prop) +(hnmatchupswins : nmatchupswins = (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) (wins : Fin (2 * n - 1) → (Fin (2 * n) → Bool)) => ∀ d : Fin (2 * n - 1), ∀ t : Fin (2 * n), wins d t = !(wins d (matchups d t)))) +(hnmatchupswinschoices : nmatchupswinschoices = (fun (n : ℕ) (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) (wins : Fin (2 * n - 1) → (Fin (2 * n) → Bool)) => ∃ choices : Fin (2 * n - 1) → Fin (2 * n), (∀ d : Fin (2 * n - 1), wins d (choices d)) ∧ Function.Injective choices)) : (∀ n ≥ 1, ∀ (matchups : Fin (2 * n - 1) → (Fin (2 * n) → Fin (2 * n))) (wins : Fin (2 * n - 1) → (Fin (2 * n) → Bool)), (nmatchupsgames n matchups ∧ nmatchupsall n matchups ∧ nmatchupswins n matchups wins) → nmatchupswinschoices n matchups wins) ↔ putnam_2012_b3_solution := sorry diff --git a/lean4/src/putnam_2013_a2.lean b/lean4/src/putnam_2013_a2.lean index c871f1a1..8e7f6779 100644 --- a/lean4/src/putnam_2013_a2.lean +++ b/lean4/src/putnam_2013_a2.lean @@ -4,10 +4,13 @@ open BigOperators open Function Set theorem putnam_2013_a2 -(S : Set ℤ := {n : ℤ | n > 0 ∧ ¬∃ m : ℤ, m ^ 2 = n}) -(P : ℤ → List ℤ → Prop := fun n : ℤ => fun a : List ℤ => a.length > 0 ∧ n < a[0]! ∧ +(S : Set ℤ) +(hS : S = {n : ℤ | n > 0 ∧ ¬∃ m : ℤ, m ^ 2 = n}) +(P : ℤ → List ℤ → Prop) +(hP : P = fun n : ℤ => fun a : List ℤ => a.length > 0 ∧ n < a[0]! ∧ (∃ m : ℤ, m ^ 2 = n * a.prod) ∧ (∀ i : Fin (a.length - 1), a[i] < a[i+(1:ℕ)])) -(T : ℤ → Set ℤ := fun n : ℤ => {m : ℤ | ∃ a : List ℤ, P n a ∧ a[a.length - 1]! = m}) +(T : ℤ → Set ℤ) +(hT : T = fun n : ℤ => {m : ℤ | ∃ a : List ℤ, P n a ∧ a[a.length - 1]! = m}) (f : ℤ → ℤ) (hf : ∀ n ∈ S, ((∃ r ∈ T n, f n = r) ∧ ∀ r ∈ T n, f n ≤ r)) : InjOn f S := diff --git a/lean4/src/putnam_2013_b2.lean b/lean4/src/putnam_2013_b2.lean index 1f858ab9..81390e72 100644 --- a/lean4/src/putnam_2013_b2.lean +++ b/lean4/src/putnam_2013_b2.lean @@ -6,9 +6,11 @@ open Function Set abbrev putnam_2013_b2_solution : ℝ := sorry -- 3 theorem putnam_2013_b2 -(CN : ℕ → Set (ℝ → ℝ) := fun N : ℕ => {f : ℝ → ℝ | (∀ x : ℝ, f x ≥ 0) ∧ +(CN : ℕ → Set (ℝ → ℝ)) +(C : Set (ℝ → ℝ)) +(hCN : CN = fun N : ℕ => {f : ℝ → ℝ | (∀ x : ℝ, f x ≥ 0) ∧ ∃ a : List ℝ, a.length = N + 1 ∧ (∀ n : Fin (N + 1), 3 ∣ (n : ℕ) → a[n]! = 0) ∧ ∀ x : ℝ, f x = 1 + ∑ n in Finset.Icc 1 N, a[(n : ℕ)]! * Real.cos (2*Real.pi*n*x)}) -(C : Set (ℝ → ℝ) := ⋃ N ∈ Ici 1, CN N) +(hC : C = ⋃ N ∈ Ici 1, CN N) : (∀ f ∈ C, f 0 ≤ putnam_2013_b2_solution) ∧ ∃ f ∈ C, f 0 = putnam_2013_b2_solution := sorry diff --git a/lean4/src/putnam_2014_a4.lean b/lean4/src/putnam_2014_a4.lean index fec9402a..714e5217 100644 --- a/lean4/src/putnam_2014_a4.lean +++ b/lean4/src/putnam_2014_a4.lean @@ -6,7 +6,9 @@ open Topology Filter Nat noncomputable abbrev putnam_2014_a4_solution : ℝ := sorry -- 1 / 3 theorem putnam_2014_a4 -(Xrandvar : (ℕ → ℝ) → Prop := (fun X : ℕ → ℝ => (∀ n : ℕ, X n ∈ Set.Icc 0 1) ∧ ∑' n : ℕ, X n = 1)) -(E : (ℕ → ℝ) → (ℕ → ℝ) → ℝ := (fun (X : ℕ → ℝ) (f : ℕ → ℝ) => ∑' n : ℕ, f n * X n)) +(Xrandvar : (ℕ → ℝ) → Prop) +(hXrandvar : Xrandvar = (fun X : ℕ → ℝ => (∀ n : ℕ, X n ∈ Set.Icc 0 1) ∧ ∑' n : ℕ, X n = 1)) +(E : (ℕ → ℝ) → (ℕ → ℝ) → ℝ) +(hE : E = (fun (X : ℕ → ℝ) (f : ℕ → ℝ) => ∑' n : ℕ, f n * X n)) : sInf {X0 : ℝ | ∃ X : ℕ → ℝ, Xrandvar X ∧ E X (fun x : ℕ => x) = 1 ∧ E X (fun x : ℕ => x ^ 2) = 2 ∧ E X (fun x : ℕ => x ^ 3) = 5 ∧ X0 = X 0} = putnam_2014_a4_solution := sorry diff --git a/lean4/src/putnam_2014_b1.lean b/lean4/src/putnam_2014_b1.lean index 0cfd8db1..485fb3d8 100644 --- a/lean4/src/putnam_2014_b1.lean +++ b/lean4/src/putnam_2014_b1.lean @@ -6,7 +6,8 @@ open Topology Filter Nat abbrev putnam_2014_b1_solution : Set ℕ := sorry -- {n : ℕ | n > 0 ∧ ¬∃ a ∈ digits 10 n, a = 0} theorem putnam_2014_b1 -(overexpansion : ℕ → List ℕ → Prop := fun N d ↦ N = ∑ i : Fin d.length, (d.get i) * 10 ^ i.1 ∧ d.getLastI ≠ 0 ∧ ∀ a ∈ d, a ∈ Finset.range 11) +(overexpansion : ℕ → List ℕ → Prop) +(hoverexpansion : overexpansion = fun N d ↦ N = ∑ i : Fin d.length, (d.get i) * 10 ^ i.1 ∧ d.getLastI ≠ 0 ∧ ∀ a ∈ d, a ∈ Finset.range 11) (S : Set ℕ) (hS : ∀ N : ℕ, N ∈ S ↔ N > 0 ∧ ∃! d : List ℕ, overexpansion N d) : (S = putnam_2014_b1_solution) := diff --git a/lean4/src/putnam_2014_b2.lean b/lean4/src/putnam_2014_b2.lean index 68f44d1e..f107aa2c 100644 --- a/lean4/src/putnam_2014_b2.lean +++ b/lean4/src/putnam_2014_b2.lean @@ -7,8 +7,10 @@ open Topology Filter Nat noncomputable abbrev putnam_2014_b2_solution : ℝ := sorry -- Real.log (4 / 3) theorem putnam_2014_b2 -(fbound : (ℝ → ℝ) → Prop := (fun f : ℝ → ℝ => ∀ x : Set.Icc (1 : ℝ) 3, -1 ≤ f x ∧ f x ≤ 1)) -(finteq0 : (ℝ → ℝ) → Prop := (fun f : ℝ → ℝ => (∫ x in Set.Ioo 1 3, f x) = 0)) -(fint : (ℝ → ℝ) → ℝ := (fun f : ℝ → ℝ => ∫ x in Set.Ioo 1 3, (f x) / x)) +(fbound finteq0 : (ℝ → ℝ) → Prop) +(fint : (ℝ → ℝ) → ℝ) +(hfbound : fbound = (fun f : ℝ → ℝ => ∀ x : Set.Icc (1 : ℝ) 3, -1 ≤ f x ∧ f x ≤ 1)) +(hfinteq0 : finteq0 = (fun f : ℝ → ℝ => (∫ x in Set.Ioo 1 3, f x) = 0)) +(hfint : fint = (fun f : ℝ → ℝ => ∫ x in Set.Ioo 1 3, (f x) / x)) : (∃ f : ℝ → ℝ, fbound f ∧ finteq0 f ∧ fint f = putnam_2014_b2_solution) ∧ (∀ f : ℝ → ℝ, (fbound f ∧ finteq0 f) → fint f ≤ putnam_2014_b2_solution) := sorry diff --git a/lean4/src/putnam_2015_a1.lean b/lean4/src/putnam_2015_a1.lean index 0ed96d49..cb1ea3df 100644 --- a/lean4/src/putnam_2015_a1.lean +++ b/lean4/src/putnam_2015_a1.lean @@ -2,7 +2,8 @@ import Mathlib open BigOperators theorem putnam_2015_a1 -(hyperbola : Set (Fin 2 → ℝ) := {p : Fin 2 → ℝ | p 1 = 1 / p 0 ∧ p 0 > 0}) +(hyperbola : Set (Fin 2 → ℝ)) +(hhyperbola : hyperbola = {p : Fin 2 → ℝ | p 1 = 1 / p 0 ∧ p 0 > 0}) (A B : Fin 2 → ℝ) (P : Fin 2 → ℝ) (PPline : (Fin 2 → ℝ) → (Fin 2 → ℝ) → (ℝ → ℝ)) diff --git a/lean4/src/putnam_2015_a4.lean b/lean4/src/putnam_2015_a4.lean index 67609a06..28297614 100644 --- a/lean4/src/putnam_2015_a4.lean +++ b/lean4/src/putnam_2015_a4.lean @@ -4,9 +4,12 @@ open BigOperators noncomputable abbrev putnam_2015_a4_solution : ℝ := sorry -- 4 / 7 theorem putnam_2015_a4 -(S : ℝ → Set ℤ := fun x ↦ {n : ℤ | n > 0 ∧ Even ⌊n * x⌋}) -(f : ℝ → ℝ := fun x ↦ ∑' n : S x, 1 / 2 ^ (n : ℤ)) -(p : ℝ → Prop := fun l ↦ ∀ x ∈ Set.Ico 0 1, f x ≥ l) +(S : ℝ → Set ℤ) +(f : ℝ → ℝ) +(p : ℝ → Prop) +(hS : S = fun (x : ℝ) ↦ {n : ℤ | n > 0 ∧ Even ⌊n * x⌋}) +(hf : f = fun (x : ℝ) ↦ ∑' n : S x, 1 / 2 ^ (n : ℤ)) +(hp : p = fun (l : ℝ) ↦ ∀ x ∈ Set.Ico 0 1, f x ≥ l) (L : ℝ) (hpL : p L) (hLub : ∀ l : ℝ, p l → l ≤ L) diff --git a/lean4/src/putnam_2015_b5.lean b/lean4/src/putnam_2015_b5.lean index 216d8ed8..4ff832e6 100644 --- a/lean4/src/putnam_2015_b5.lean +++ b/lean4/src/putnam_2015_b5.lean @@ -6,6 +6,7 @@ open Function abbrev putnam_2015_b5_solution : ℕ := sorry -- 4 theorem putnam_2015_b5 -(P : ℕ → ℕ := fun n ↦ {pi : Finset.Icc 1 n → Finset.Icc 1 n | Bijective pi ∧ ∀ i j : Finset.Icc 1 n, Nat.dist i j = 1 → Nat.dist (pi i) (pi j) ≤ 2}.ncard) +(P : ℕ → ℕ) +(hP : P = fun n ↦ {pi : Finset.Icc 1 n → Finset.Icc 1 n | Bijective pi ∧ ∀ i j : Finset.Icc 1 n, Nat.dist i j = 1 → Nat.dist (pi i) (pi j) ≤ 2}.ncard) : (∀ n : ℕ, n ≥ 2 → (P (n + 5) : ℤ) - (P (n + 4) : ℤ) - (P (n + 3) : ℤ) + (P n : ℤ) = putnam_2015_b5_solution) := sorry diff --git a/lean4/src/putnam_2016_a2.lean b/lean4/src/putnam_2016_a2.lean index 3152ecb3..bf058516 100644 --- a/lean4/src/putnam_2016_a2.lean +++ b/lean4/src/putnam_2016_a2.lean @@ -6,7 +6,8 @@ open Polynomial Filter Topology Real Set Nat noncomputable abbrev putnam_2016_a2_solution : ℝ := sorry -- (3 + sqrt 5) / 2 theorem putnam_2016_a2 -(p : ℕ → ℕ → Prop := fun n ↦ fun m ↦ Nat.choose m (n - 1) > Nat.choose (m - 1) n) +(p : ℕ → ℕ → Prop) +(hp : p = fun n ↦ fun m ↦ Nat.choose m (n - 1) > Nat.choose (m - 1) n) (M : ℕ → ℕ) (hpM : ∀ n : ℕ, p n (M n)) (hMub : ∀ n : ℕ, ∀ m : ℕ, p n m → m ≤ M n) diff --git a/lean4/src/putnam_2016_a5.lean b/lean4/src/putnam_2016_a5.lean index be0fadf4..5d33e77c 100644 --- a/lean4/src/putnam_2016_a5.lean +++ b/lean4/src/putnam_2016_a5.lean @@ -9,6 +9,7 @@ theorem putnam_2016_a5 (g h : G) (ghgen : Group.closure {g, h} = G ∧ ¬Group.closure {g} = G ∧ ¬Group.closure {h} = G) (godd : Odd (orderOf g)) -(S : Set G := {g * h, g⁻¹ * h, g * h⁻¹, g⁻¹ * h⁻¹}) +(S : Set G) +(hS : S = {g * h, g⁻¹ * h, g * h⁻¹, g⁻¹ * h⁻¹}) : (∀ x : G, ∃ mn : List G, 1 ≤ mn.length ∧ mn.length ≤ Gfin.card ∧ ∀ i : Fin mn.length, mn.get i ∈ S ∧ x = List.prod mn) := sorry diff --git a/lean4/src/putnam_2016_a6.lean b/lean4/src/putnam_2016_a6.lean index 213f1455..91e86d10 100644 --- a/lean4/src/putnam_2016_a6.lean +++ b/lean4/src/putnam_2016_a6.lean @@ -10,7 +10,8 @@ theorem putnam_2016_a6 (max : Polynomial ℝ → ℝ) (hmax : ∀ P : Polynomial ℝ, ∃ x ∈ Icc 0 1, |P.eval x| = max P) (hmaxub : ∀ P : Polynomial ℝ, ∀ x ∈ Icc 0 1, |P.eval x| ≤ max P) -(p : ℝ → Prop := fun c ↦ ∀ P : Polynomial ℝ, P.degree = 3 → (∃ x ∈ Icc 0 1, P.eval x = 0) → ∫ x in (0)..1, |P.eval x| ≤ c * max P) +(p : ℝ → Prop) +(hp : p = fun c ↦ ∀ P : Polynomial ℝ, P.degree = 3 → (∃ x ∈ Icc 0 1, P.eval x = 0) → ∫ x in (0)..1, |P.eval x| ≤ c * max P) (hpC : p C) (hClb : ∀ c : ℝ, p c → C ≤ c) : (C = putnam_2016_a6_solution) := diff --git a/lean4/src/putnam_2016_b2.lean b/lean4/src/putnam_2016_b2.lean index 4e545a6d..4d0b3317 100644 --- a/lean4/src/putnam_2016_b2.lean +++ b/lean4/src/putnam_2016_b2.lean @@ -6,8 +6,11 @@ open Polynomial Filter Topology Real Set Nat List noncomputable abbrev putnam_2016_b2_solution : ℝ × ℝ := sorry -- (3 / 4, 4 / 3) theorem putnam_2016_b2 -(squarish : ℤ → Prop := fun n ↦ IsSquare n ∨ ∃ w : ℤ, IsSquare |n - w ^ 2| ∧ ∀ v : ℕ, |n - w ^ 2| ≤ |n - v ^ 2|) -(S : ℤ → ℕ := fun n ↦ {i ∈ Finset.Icc 1 n | squarish i}.ncard) -(p : ℝ → ℝ → Prop := fun α ↦ fun β ↦ α > 0 ∧ β > 0 ∧ Tendsto (fun N ↦ S N / (N : ℝ) ^ α) atTop (𝓝 β)) +(squarish : ℤ → Prop) +(hsquarish : squarish = fun n ↦ IsSquare n ∨ ∃ w : ℤ, IsSquare |n - w ^ 2| ∧ ∀ v : ℕ, |n - w ^ 2| ≤ |n - v ^ 2|) +(S : ℤ → ℕ) +(hS : S = fun n ↦ {i ∈ Finset.Icc 1 n | squarish i}.ncard) +(p : ℝ → ℝ → Prop) +(hp : p = fun α ↦ fun β ↦ α > 0 ∧ β > 0 ∧ Tendsto (fun N ↦ S N / (N : ℝ) ^ α) atTop (𝓝 β)) : ((∀ α β : ℝ, ((α, β) = putnam_2016_b2_solution ↔ p α β)) ∨ ¬∃ α β : ℝ, p α β) := sorry diff --git a/lean4/src/putnam_2016_b4.lean b/lean4/src/putnam_2016_b4.lean index 100b404e..224d767a 100644 --- a/lean4/src/putnam_2016_b4.lean +++ b/lean4/src/putnam_2016_b4.lean @@ -1,13 +1,14 @@ import Mathlib open BigOperators -open Polynomial Filter Topology Real Set Nat List +open Real Set Nat noncomputable abbrev putnam_2016_b4_solution : ℕ → ℝ := sorry -- (fun n : ℕ => (2 * n)! / (4 ^ n * (n)!)) theorem putnam_2016_b4 (n : ℕ) -(mats01 : Set (Matrix (Fin (2 * n)) (Fin (2 * n)) ℝ) := {A : Matrix (Fin (2 * n)) (Fin (2 * n)) ℝ | ∀ i j : Fin (2 * n), A i j = 0 ∨ A i j = 1}) (npos : n ≥ 1) +(mats01 : Set (Matrix (Fin (2 * n)) (Fin (2 * n)) ℝ)) +(hmats01 : mats01 = {A : Matrix (Fin (2 * n)) (Fin (2 * n)) ℝ | ∀ i j : Fin (2 * n), A i j = 0 ∨ A i j = 1}) : (∑' A : mats01, (A.1 - (Matrix.transpose A)).det) / mats01.ncard = putnam_2016_b4_solution n := sorry diff --git a/lean4/src/putnam_2017_b1.lean b/lean4/src/putnam_2017_b1.lean index 0b090a7c..7f055d13 100644 --- a/lean4/src/putnam_2017_b1.lean +++ b/lean4/src/putnam_2017_b1.lean @@ -4,9 +4,10 @@ open BigOperators open Topology Filter theorem putnam_2017_b1 -(lines : Set (Set (Fin 2 → ℝ)) := {L : Set (Fin 2 → ℝ) | ∃ v w : Fin 2 → ℝ, w ≠ 0 ∧ L = {p : Fin 2 → ℝ | ∃ t : ℝ, p = v + t • w}}) +(lines : Set (Set (Fin 2 → ℝ))) (L1 L2 : Set (Fin 2 → ℝ)) (L1L2lines : L1 ∈ lines ∧ L2 ∈ lines) (L1L2distinct : L1 ≠ L2) +(hlines : lines = {L : Set (Fin 2 → ℝ) | ∃ v w : Fin 2 → ℝ, w ≠ 0 ∧ L = {p : Fin 2 → ℝ | ∃ t : ℝ, p = v + t • w}}) : L1 ∩ L2 ≠ ∅ ↔ (∀ lambda : ℝ, lambda ≠ 0 → ∀ P : Fin 2 → ℝ, (P ∉ L1 ∧ P ∉ L2) → ∃ A1 A2 : Fin 2 → ℝ, A1 ∈ L1 ∧ A2 ∈ L2 ∧ (A2 - P = lambda • (A1 - P))) := sorry diff --git a/lean4/src/putnam_2017_b2.lean b/lean4/src/putnam_2017_b2.lean index 7ee7d312..2c51ddb1 100644 --- a/lean4/src/putnam_2017_b2.lean +++ b/lean4/src/putnam_2017_b2.lean @@ -8,9 +8,12 @@ abbrev putnam_2017_b2_solution : ℕ := sorry theorem putnam_2017_b2 (mina : ℤ) (hmina : mina ≥ 0) -(S : ℤ → ℕ → ℤ := fun a k ↦ ∑ i : Fin k, a + i) -(p : ℤ → ℕ → Prop := fun N k ↦ ∃ a > 0, S a k = N) -(q : ℤ → Prop := fun N ↦ p N 2017 ∧ ∀ k : ℕ, k > 1 → k ≠ 2017 → ¬p N k) +(S : ℤ → ℕ → ℤ) +(p : ℤ → ℕ → Prop) +(q : ℤ → Prop) +(hS : S = fun a k ↦ ∑ i : Fin k, a + i) +(hp : p = fun N k ↦ ∃ a > 0, S a k = N) +(hq : q = fun N ↦ p N 2017 ∧ ∀ k : ℕ, k > 1 → k ≠ 2017 → ¬p N k) (hqmina : q (S mina 2017)) (hminalb : ∀ a > 0, q (S a 2017) → mina ≤ a) : (mina = putnam_2017_b2_solution) := diff --git a/lean4/src/putnam_2018_a3.lean b/lean4/src/putnam_2018_a3.lean index b32215ff..17b7989f 100644 --- a/lean4/src/putnam_2018_a3.lean +++ b/lean4/src/putnam_2018_a3.lean @@ -5,7 +5,8 @@ noncomputable abbrev putnam_2018_a3_solution : ℝ := sorry -- 480/49 theorem putnam_2018_a3 (P : Set (Fin 10 → ℝ)) -(f : (Fin 10 → ℝ) → ℝ → ℝ := fun x => fun k => ∑ i : Fin 10, Real.cos (k * (x i))) +(f : (Fin 10 → ℝ) → ℝ → ℝ) +(hf : f = fun x => fun k => ∑ i : Fin 10, Real.cos (k * (x i))) (hP : ∀ x ∈ P, f x 1 = 0) : ∀ y ∈ P, f y 3 ≤ putnam_2018_a3_solution ∧ ∃ x ∈ P, f x 3 = putnam_2018_a3_solution := sorry diff --git a/lean4/src/putnam_2018_a6.lean b/lean4/src/putnam_2018_a6.lean index 88bdcbab..54dc0fd5 100644 --- a/lean4/src/putnam_2018_a6.lean +++ b/lean4/src/putnam_2018_a6.lean @@ -3,7 +3,8 @@ open BigOperators theorem putnam_2018_a6 (A B C D : EuclideanSpace ℝ (Fin 2)) -(PPprops : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Prop := (fun P1 P2 : EuclideanSpace ℝ (Fin 2) => P1 ≠ P2 ∧ (∃ q : ℚ, (dist P1 P2) ^ 2 = q))) +(PPprops : (EuclideanSpace ℝ (Fin 2)) → (EuclideanSpace ℝ (Fin 2)) → Prop) +(hPPprops : PPprops = (fun P1 P2 : EuclideanSpace ℝ (Fin 2) => P1 ≠ P2 ∧ (∃ q : ℚ, (dist P1 P2) ^ 2 = q))) (ABCDnoline : ¬Collinear ℝ {A, B, C} ∧ ¬Collinear ℝ {A, B, D} ∧ ¬Collinear ℝ {A, C, D} ∧ ¬Collinear ℝ {B, C, D}) (ABCDsqrrat : PPprops A B ∧ PPprops A C ∧ PPprops A D ∧ PPprops B C ∧ PPprops B D ∧ PPprops C D) : ∃ q : ℚ, (MeasureTheory.volume (convexHull ℝ {A, B, C}) / MeasureTheory.volume (convexHull ℝ {A, B, D})).toReal = q := diff --git a/lean4/src/putnam_2018_b5.lean b/lean4/src/putnam_2018_b5.lean index 00ec108b..0949e71e 100644 --- a/lean4/src/putnam_2018_b5.lean +++ b/lean4/src/putnam_2018_b5.lean @@ -3,10 +3,12 @@ open BigOperators theorem putnam_2018_b5 (f : ℝ → ℝ → (Fin 2 → ℝ)) -(fpart1 : Fin 2 → ℝ → (ℝ → ℝ) := (fun (i : Fin 2) (x2 : ℝ) => (fun x1 : ℝ => (f x1 x2) i))) -(fpart2 : Fin 2 → ℝ → (ℝ → ℝ) := (fun (i : Fin 2) (x1 : ℝ) => (fun x2 : ℝ => (f x1 x2) i))) -(fdiff : ∀ (i : Fin 2) (x : ℝ), ContDiff ℝ 1 (fpart1 i x) ∧ ContDiff ℝ 1 (fpart2 i x)) -(fpos : ∀ (i : Fin 2) (x : ℝ), deriv (fpart1 i x) > 0 ∧ deriv (fpart2 i x) > 0) -(fexprgt0 : ∀ x1 x2 : ℝ, (deriv (fpart1 0 x2) x1) * (deriv (fpart2 1 x1) x2) - (1 / 4) * ((deriv (fpart2 0 x1) x2) + (deriv (fpart1 1 x2) x1)) ^ 2 > 0) +(fpart1 : Fin 2 → ℝ → (ℝ → ℝ)) +(fpart2 : Fin 2 → ℝ → (ℝ → ℝ)) +(hfpart1 : fpart1 = (fun (i : Fin 2) (x2 : ℝ) => (fun x1 : ℝ => (f x1 x2) i))) +(hfpart2 : fpart2 = (fun (i : Fin 2) (x1 : ℝ) => (fun x2 : ℝ => (f x1 x2) i))) +(hfdiff : ∀ (i : Fin 2) (x : ℝ), ContDiff ℝ 1 (fpart1 i x) ∧ ContDiff ℝ 1 (fpart2 i x)) +(hfpos : ∀ (i : Fin 2) (x : ℝ), deriv (fpart1 i x) > 0 ∧ deriv (fpart2 i x) > 0) +(hfexprgt0 : ∀ x1 x2 : ℝ, (deriv (fpart1 0 x2) x1) * (deriv (fpart2 1 x1) x2) - (1 / 4) * ((deriv (fpart2 0 x1) x2) + (deriv (fpart1 1 x2) x1)) ^ 2 > 0) : Function.Injective f := sorry diff --git a/lean4/src/putnam_2019_a3.lean b/lean4/src/putnam_2019_a3.lean index d72b3a4e..c8ad4bbb 100644 --- a/lean4/src/putnam_2019_a3.lean +++ b/lean4/src/putnam_2019_a3.lean @@ -6,9 +6,11 @@ open Topology Filter noncomputable abbrev putnam_2019_a3_solution : ℝ := sorry -- 2019^(-(1:ℝ)/2019) theorem putnam_2019_a3 -(v : Polynomial ℂ → Prop := fun b : Polynomial ℂ => b.degree = 2019 ∧ 1 ≤ (b.coeff 0).re ∧ (b.coeff 2019).re ≤ 2019 ∧ +(v : Polynomial ℂ → Prop) +(hv : v = fun b : Polynomial ℂ => b.degree = 2019 ∧ 1 ≤ (b.coeff 0).re ∧ (b.coeff 2019).re ≤ 2019 ∧ (∀ i : Fin 2020, (b.coeff i).im = 0) ∧ (∀ i : Fin 2019, (b.coeff i).re < (b.coeff (i + 1)).re)) -(μ : Polynomial ℂ → ℝ := fun b : Polynomial ℂ => (Multiset.map (fun ω : ℂ => ‖ω‖) (Polynomial.roots b)).sum/2019) +(μ : Polynomial ℂ → ℝ) +(hμ : μ = fun b : Polynomial ℂ => (Multiset.map (fun ω : ℂ => ‖ω‖) (Polynomial.roots b)).sum/2019) : (∀ b : Polynomial ℂ, v b → μ b ≥ putnam_2019_a3_solution) ∧ ∀ M : ℝ, (∀ b : Polynomial ℂ, v b → μ b ≥ M) → M ≤ putnam_2019_a3_solution := sorry diff --git a/lean4/src/putnam_2019_b2.lean b/lean4/src/putnam_2019_b2.lean index aad22557..c23e32d5 100644 --- a/lean4/src/putnam_2019_b2.lean +++ b/lean4/src/putnam_2019_b2.lean @@ -6,7 +6,8 @@ open Topology Filter Set noncomputable abbrev putnam_2019_b2_solution : ℝ := sorry -- 8/Real.pi^3 theorem putnam_2019_b2 -(a : ℕ → ℝ := fun n : ℕ => ∑ k : Icc (1 : ℤ) (n - 1), +(a : ℕ → ℝ) +(ha : a = fun n : ℕ => ∑ k : Icc (1 : ℤ) (n - 1), Real.sin ((2*k - 1)*Real.pi/(2*n))/((Real.cos ((k - 1)*Real.pi/(2*n))^2)*(Real.cos (k*Real.pi/(2*n))^2))) : Tendsto (fun n : ℕ => (a n)/n^3) atTop (𝓝 putnam_2019_b2_solution) := sorry diff --git a/lean4/src/putnam_2019_b3.lean b/lean4/src/putnam_2019_b3.lean index 9337c8e9..f9bf0bd2 100644 --- a/lean4/src/putnam_2019_b3.lean +++ b/lean4/src/putnam_2019_b3.lean @@ -11,6 +11,7 @@ theorem putnam_2019_b3 (hQ1 : ∀ i : Fin n, dotProduct (Q i) (Q i) = 1 ∧ dotProduct (Qᵀ i) (Qᵀ i) = 1) (u : Matrix (Fin n) (Fin 1) ℝ) (hu : uᵀ*u = 1) -(P : Matrix (Fin n) (Fin n) ℝ := 1 - (u * uᵀ)) +(P : Matrix (Fin n) (Fin n) ℝ) +(hP : P = 1 - (u * uᵀ)) : (Q - 1).det ≠ 0 → (P * Q - 1).det = 0 := sorry diff --git a/lean4/src/putnam_2020_a5.lean b/lean4/src/putnam_2020_a5.lean index 14cbc3b7..bbeb95b8 100644 --- a/lean4/src/putnam_2020_a5.lean +++ b/lean4/src/putnam_2020_a5.lean @@ -6,6 +6,7 @@ open Filter Topology Set abbrev putnam_2020_a5_solution : ℤ := sorry -- (Nat.fib 4040) - 1 theorem putnam_2020_a5 -(a : ℤ → ℕ := fun n : ℤ => {S : Finset ℕ | (∀ k ∈ S, k > 0) ∧ ∑ k : S, Nat.fib k = n}.ncard) +(a : ℤ → ℕ) +(ha : a = fun n : ℤ => {S : Finset ℕ | (∀ k ∈ S, k > 0) ∧ ∑ k : S, Nat.fib k = n}.ncard) : a putnam_2020_a5_solution = 2020 ∧ ∀ n : ℤ, a n = 2020 → n ≤ putnam_2020_a5_solution := sorry diff --git a/lean4/src/putnam_2020_a6.lean b/lean4/src/putnam_2020_a6.lean index 9f178c15..38b77921 100644 --- a/lean4/src/putnam_2020_a6.lean +++ b/lean4/src/putnam_2020_a6.lean @@ -6,7 +6,8 @@ open Filter Topology Set noncomputable abbrev putnam_2020_a6_solution : ℝ := sorry -- Real.pi / 4 theorem putnam_2020_a6 -(f : ℤ → (ℝ → ℝ) := fun N : ℤ => fun x : ℝ => +(f : ℤ → (ℝ → ℝ)) +(hf : f = fun N : ℤ => fun x : ℝ => ∑ n in Finset.Icc 0 N, (N + 1/2 - n)/((N + 1)*(2*n + 1)) * Real.sin ((2*n + 1)*x)) : (∀ N > 0, ∀ x : ℝ, f N x ≤ putnam_2020_a6_solution) ∧ ∀ M : ℝ, (∀ N > 0, ∀ x : ℝ, f N x ≤ M) → M ≥ putnam_2020_a6_solution := diff --git a/lean4/src/putnam_2020_b1.lean b/lean4/src/putnam_2020_b1.lean index 417e0b10..7329b53d 100644 --- a/lean4/src/putnam_2020_b1.lean +++ b/lean4/src/putnam_2020_b1.lean @@ -6,7 +6,9 @@ open Filter Topology Set abbrev putnam_2020_b1_solution : ℕ := sorry -- 1990 theorem putnam_2020_b1 -(d : ℕ → ℕ := fun n : ℕ => ∑ i : Fin (Nat.digits 2 n).length, (Nat.digits 2 n)[i]!) -(S : ℤ := ∑ k : Icc 1 2020, ((-1)^(d k))*(k : ℕ)^3) +(d : ℕ → ℕ) +(S : ℤ) +(hd : d = fun n : ℕ => ∑ i : Fin (Nat.digits 2 n).length, (Nat.digits 2 n)[i]!) +(hS : S = ∑ k : Icc 1 2020, ((-1 : ℤ)^(d k))*(k : ℤ)^3) : S % 2020 = putnam_2020_b1_solution := sorry diff --git a/lean4/src/putnam_2020_b4.lean b/lean4/src/putnam_2020_b4.lean index 8f278ffd..d6381570 100644 --- a/lean4/src/putnam_2020_b4.lean +++ b/lean4/src/putnam_2020_b4.lean @@ -6,8 +6,11 @@ open Filter Topology Set noncomputable abbrev putnam_2020_b4_solution : ℝ := sorry -- 1 / 4040 theorem putnam_2020_b4 -(V : ℕ → Set (ℕ → ℤ) := fun n ↦ ({s : ℕ → ℤ | s 0 = 0 ∧ (∀ j ≥ 2 * n, s j = 0) ∧ (∀ j ∈ Icc 1 (2 * n), |s j - s (j - 1)| = 1)})) -(q : ℕ → (ℕ → ℤ) → ℝ := fun n s ↦ 1 + ∑ j in Finset.Icc 1 (2 * n - 1), 3 ^ (s j)) -(M : ℕ → ℝ := fun n ↦ (∑' v : V n, 1 / (q n v)) / (V n).ncard) +(V : ℕ → Set (ℕ → ℤ)) +(q : ℕ → (ℕ → ℤ) → ℝ) +(M : ℕ → ℝ) +(hV : V = fun n ↦ ({s : ℕ → ℤ | s 0 = 0 ∧ (∀ j ≥ 2 * n, s j = 0) ∧ (∀ j ∈ Icc 1 (2 * n), |s j - s (j - 1)| = 1)})) +(hq : q = fun n s ↦ 1 + ∑ j in Finset.Icc 1 (2 * n - 1), 3 ^ (s j)) +(hM : M = fun n ↦ (∑' v : V n, 1 / (q n v)) / (V n).ncard) : (M 2020 = putnam_2020_b4_solution) := sorry diff --git a/lean4/src/putnam_2021_a1.lean b/lean4/src/putnam_2021_a1.lean index a8f43da2..56baab6a 100644 --- a/lean4/src/putnam_2021_a1.lean +++ b/lean4/src/putnam_2021_a1.lean @@ -6,7 +6,8 @@ open Filter Topology abbrev putnam_2021_a1_solution : ℕ := sorry -- 578 theorem putnam_2021_a1 -(P : List (ℤ × ℤ) → Prop := fun l : List (ℤ × ℤ) => l.length ≥ 1 ∧ l[0]! = (0, 0) ∧ l[l.length-1]! = (2021, 2021) ∧ +(P : List (ℤ × ℤ) → Prop) +(hP : P = fun l : List (ℤ × ℤ) => l.length ≥ 1 ∧ l[0]! = (0, 0) ∧ l[l.length-1]! = (2021, 2021) ∧ ∀ n ∈ Finset.range (l.length-1), Real.sqrt ((l[n]!.1 - l[n + 1]!.1)^2 + (l[n]!.2 - l[n + 1]!.2)^2) = 5) : (∃ l : List (ℤ × ℤ), P l ∧ l.length = putnam_2021_a1_solution) ∧ ∀ l : List (ℤ × ℤ), P l → l.length ≥ putnam_2021_a1_solution := diff --git a/lean4/src/putnam_2021_a3.lean b/lean4/src/putnam_2021_a3.lean index 847af9d4..41b1e68a 100644 --- a/lean4/src/putnam_2021_a3.lean +++ b/lean4/src/putnam_2021_a3.lean @@ -7,9 +7,12 @@ abbrev putnam_2021_a3_solution : Set ℕ := sorry -- {3 * m ^ 2 | m > 0} theorem putnam_2021_a3 (N : ℕ) -(Nsphere : Set (EuclideanSpace ℝ (Fin 3)) := {p : EuclideanSpace ℝ (Fin 3) | (p 0) ^ 2 + (p 1) ^ 2 + (p 2) ^ 2 = (N : ℝ)}) -(intcoords : (EuclideanSpace ℝ (Fin 3)) → Prop := (fun p : EuclideanSpace ℝ (Fin 3) => ∀ i : Fin 3, p i = round (p i))) -(Ntetra : Prop := ∃ A B C D : EuclideanSpace ℝ (Fin 3), A ∈ Nsphere ∧ B ∈ Nsphere ∧ C ∈ Nsphere ∧ D ∈ Nsphere ∧ intcoords A ∧ intcoords B ∧ intcoords C ∧ intcoords D ∧ +(Nsphere : Set (EuclideanSpace ℝ (Fin 3))) +(hNsphere : Nsphere = {p : EuclideanSpace ℝ (Fin 3) | (p 0) ^ 2 + (p 1) ^ 2 + (p 2) ^ 2 = (N : ℝ)}) +(intcoords : (EuclideanSpace ℝ (Fin 3)) → Prop) +(hintcoords : intcoords = fun p : EuclideanSpace ℝ (Fin 3) => ∀ i : Fin 3, p i = round (p i)) +(Ntetra : Prop) +(hNtetra : Ntetra = ∃ A B C D : EuclideanSpace ℝ (Fin 3), A ∈ Nsphere ∧ B ∈ Nsphere ∧ C ∈ Nsphere ∧ D ∈ Nsphere ∧ intcoords A ∧ intcoords B ∧ intcoords C ∧ intcoords D ∧ (∃ s > 0, dist A B = s ∧ dist A C = s ∧ dist A D = s ∧ dist B C = s ∧ dist B D = s ∧ dist C D = s)) : (N > 0 ∧ Ntetra) ↔ N ∈ putnam_2021_a3_solution := sorry diff --git a/lean4/src/putnam_2021_a4.lean b/lean4/src/putnam_2021_a4.lean index fb64de73..6a74c6b1 100644 --- a/lean4/src/putnam_2021_a4.lean +++ b/lean4/src/putnam_2021_a4.lean @@ -1,13 +1,15 @@ import Mathlib open BigOperators -open Filter Topology +open Filter Topology Metric noncomputable abbrev putnam_2021_a4_solution : ℝ := sorry -- ((Real.sqrt 2) / 2) * Real.pi * Real.log 2 theorem putnam_2021_a4 -(S : ℝ → Set (Fin 2 → ℝ) := fun R : ℝ => {p : (Fin 2 → ℝ) | (p 0)^2 + (p 1)^2 ≤ R^2}) -(I : ℝ → ℝ := fun R : ℝ => ∫ p in S R, +(S : ℝ → Set (EuclideanSpace ℝ (Fin 2))) +(hS : S = fun R : ℝ => ball (0 : EuclideanSpace ℝ (Fin 2)) R) +(I : ℝ → ℝ) +(hI : I = fun R : ℝ => ∫ p in S R, (1 + 2*(p 0)^2)/(1 + (p 0)^4 + 6*(p 0)^2*(p 1)^2 + (p 1)^4) - (1 + (p 1)^2)/(2 + (p 0)^4 + (p 1)^4)) : Tendsto I atTop (𝓝 putnam_2021_a4_solution) := sorry diff --git a/lean4/src/putnam_2021_b3.lean b/lean4/src/putnam_2021_b3.lean index 96355245..42abc957 100644 --- a/lean4/src/putnam_2021_b3.lean +++ b/lean4/src/putnam_2021_b3.lean @@ -6,7 +6,9 @@ open Filter Topology Metric abbrev putnam_2021_b3_solution : Prop := sorry -- True theorem putnam_2021_b3 -(rho : ((EuclideanSpace ℝ (Fin 2)) → ℝ) → (EuclideanSpace ℝ (Fin 2)) → ℝ := (fun (h : (EuclideanSpace ℝ (Fin 2)) → ℝ) (p : EuclideanSpace ℝ (Fin 2)) => (p 1) * deriv (fun x' : ℝ => h (![x', p 1])) (p 0) - (p 0) * deriv (fun y' : ℝ => h (![p 0, y'])) (p 1))) -(circint : (EuclideanSpace ℝ (Fin 2)) → ℝ → Set (EuclideanSpace ℝ (Fin 2)) := (fun (c : EuclideanSpace ℝ (Fin 2)) (r : ℝ) => ball c r)) +(rho : ((EuclideanSpace ℝ (Fin 2)) → ℝ) → (EuclideanSpace ℝ (Fin 2)) → ℝ) +(circint : (EuclideanSpace ℝ (Fin 2)) → ℝ → Set (EuclideanSpace ℝ (Fin 2))) +(hrho : rho = (fun (h : (EuclideanSpace ℝ (Fin 2)) → ℝ) (p : EuclideanSpace ℝ (Fin 2)) => (p 1) * deriv (fun x' : ℝ => h ((WithLp.equiv 2 (EuclideanSpace ℝ (Fin 2))).symm ![x', p 1])) (p 0) - (p 0) * deriv (fun y' : ℝ => h ((WithLp.equiv 2 (EuclideanSpace ℝ (Fin 2))).symm ![p 0, y'])) (p 1))) +(hcircint : circint = (fun (c : EuclideanSpace ℝ (Fin 2)) (r : ℝ) => ball c r)) : (∀ h : (EuclideanSpace ℝ (Fin 2)) → ℝ, ContDiff ℝ 2 h → (∀ d > 0, ∀ r > 0, d > r → (∃ c : EuclideanSpace ℝ (Fin 2), dist c 0 = d ∧ (∫ p in (circint c r), rho h p) = 0))) ↔ putnam_2021_b3_solution := sorry diff --git a/lean4/src/putnam_2021_b5.lean b/lean4/src/putnam_2021_b5.lean index 998cbb10..2ff38c21 100644 --- a/lean4/src/putnam_2021_b5.lean +++ b/lean4/src/putnam_2021_b5.lean @@ -5,7 +5,8 @@ open Filter Topology theorem putnam_2021_b5 (n : ℕ) -(veryodd : Matrix (Fin n) (Fin n) ℤ → Prop := (fun A : Matrix (Fin n) (Fin n) ℤ => ∀ m ∈ Set.Icc 1 n, ∀ reind : Fin m → Fin n, Function.Injective reind → Odd (A.submatrix reind reind).det)) (npos : n ≥ 1) +(veryodd : Matrix (Fin n) (Fin n) ℤ → Prop) +(hveryodd : veryodd = (fun A : Matrix (Fin n) (Fin n) ℤ => ∀ m ∈ Set.Icc 1 n, ∀ reind : Fin m → Fin n, Function.Injective reind → Odd (A.submatrix reind reind).det)) : ∀ A : Matrix (Fin n) (Fin n) ℤ, veryodd A → (∀ k ≥ 1, veryodd (A ^ k)) := sorry diff --git a/lean4/src/putnam_2022_a2.lean b/lean4/src/putnam_2022_a2.lean index c093fd3a..8760405d 100644 --- a/lean4/src/putnam_2022_a2.lean +++ b/lean4/src/putnam_2022_a2.lean @@ -8,7 +8,9 @@ abbrev putnam_2022_a2_solution : ℕ → ℕ := sorry theorem putnam_2022_a2 (n : ℕ) (hn : n ≥ 2) -(S : Set ℝ[X] := {P : ℝ[X] | natDegree P = n}) -(negs : ℝ[X] → ℕ := fun P : ℝ[X] => ∑ i in Finset.range (P.natDegree + 1), if P.coeff i < 0 then 1 else 0) +(S : Set ℝ[X]) +(hS : S = {P : ℝ[X] | natDegree P = n}) +(negs : ℝ[X] → ℕ) +(hnegs : ∀ P : ℝ[X], negs P = ∑ i in Finset.range (P.natDegree + 1), if P.coeff i < 0 then 1 else 0) : sSup {negs (P^2) | P ∈ S} = putnam_2022_a2_solution n := sorry diff --git a/lean4/src/putnam_2022_a3.lean b/lean4/src/putnam_2022_a3.lean index 8552704f..c4c334a6 100644 --- a/lean4/src/putnam_2022_a3.lean +++ b/lean4/src/putnam_2022_a3.lean @@ -4,8 +4,8 @@ open BigOperators open Polynomial theorem putnam_2022_a3 -(p : ℕ) +(p f : ℕ) (hp : Nat.Prime p ∧ p > 5) -(f : ℕ := {a : ℕ → (ZMod p) | ∀ n : ℕ, a n ≠ 0 ∧ a n * a (n + 2) = 1 + a (n + 1)}.ncard) +(hf : f = {a : ℕ → (ZMod p) | ∀ n : ℕ, a n ≠ 0 ∧ a n * a (n + 2) = 1 + a (n + 1)}.ncard) : f ≡ 0 [MOD 5] ∨ f ≡ 2 [MOD 5] := sorry diff --git a/lean4/src/putnam_2022_b3.lean b/lean4/src/putnam_2022_b3.lean index fb89d3aa..78b858d0 100644 --- a/lean4/src/putnam_2022_b3.lean +++ b/lean4/src/putnam_2022_b3.lean @@ -7,6 +7,7 @@ open Polynomial abbrev putnam_2022_b3_solution : Prop := sorry -- True theorem putnam_2022_b3 -(recolor : (ℝ → Prop) → (ℝ → Prop) := (fun isred : ℝ → Prop => (fun d : ℝ => ∃ p q : ℝ, p > 0 ∧ q > 0 ∧ p < q ∧ isred p = isred q ∧ q - p = d))) +(recolor : (ℝ → Prop) → (ℝ → Prop)) +(hrecolor : ∀ isred : ℝ → Prop, recolor isred = (fun d : ℝ => ∃ p q : ℝ, p > 0 ∧ q > 0 ∧ p < q ∧ isred p = isred q ∧ q - p = d)) : (∀ isred : ℝ → Prop, (∃ k : ℕ, ∀ p > 0, (recolor^[k] isred) p)) ↔ putnam_2022_b3_solution := sorry diff --git a/lean4/src/putnam_2023_a2.lean b/lean4/src/putnam_2023_a2.lean index 11dbebcc..ea3586aa 100644 --- a/lean4/src/putnam_2023_a2.lean +++ b/lean4/src/putnam_2023_a2.lean @@ -10,7 +10,8 @@ theorem putnam_2023_a2 (hn : n > 0 ∧ Even n) (p : Polynomial ℝ) (hp : Polynomial.Monic p ∧ p.degree = 2*n) -(S : Set ℝ := {x : ℝ | ∃ k : ℤ, x = k ∧ 1 ≤ |k| ∧ |k| ≤ n}) +(S : Set ℝ) +(hS : S = {x : ℝ | ∃ k : ℤ, x = k ∧ 1 ≤ |k| ∧ |k| ≤ n}) (hpinv : ∀ k ∈ S, p.eval (1/k) = k^2) : {x : ℝ | p.eval (1/x) = x^2} \ S = putnam_2023_a2_solution n := sorry diff --git a/lean4/src/putnam_2023_b1.lean b/lean4/src/putnam_2023_b1.lean index 862370d5..129b3619 100644 --- a/lean4/src/putnam_2023_b1.lean +++ b/lean4/src/putnam_2023_b1.lean @@ -8,11 +8,14 @@ abbrev putnam_2023_b1_solution : ℕ → ℕ → ℕ := sorry -- (fun m n : ℕ => Nat.choose (m + n - 2) (m - 1)) theorem putnam_2023_b1 (m n : ℕ) -(initcoins : ℕ → ℕ → Bool := (fun i j : ℕ => i ≤ m - 2 ∧ j ≤ n - 2)) -(legalmove : (ℕ → ℕ → Bool) → (ℕ → ℕ → Bool) → Prop := (fun (coins1 : ℕ → ℕ → Bool) (coins2 : ℕ → ℕ → Bool) => ∃ i j : ℕ, i < m - 1 ∧ j < n - 1 ∧ +(initcoins : ℕ → ℕ → Bool) +(hinitcoins : initcoins = (fun i j : ℕ => (i ≤ m - 2 ∧ j ≤ n - 2 : Bool))) +(legalmove : (ℕ → ℕ → Bool) → (ℕ → ℕ → Bool) → Prop) +(hlegalmove : legalmove = (fun (coins1 : ℕ → ℕ → Bool) (coins2 : ℕ → ℕ → Bool) => ∃ i j : ℕ, i < m - 1 ∧ j < n - 1 ∧ coins1 i j ∧ !coins1 (i + 1) j ∧ !coins1 i (j + 1) ∧ !coins1 (i + 1) (j + 1) ∧ !coins2 i j ∧ !coins2 (i + 1) j ∧ !coins2 i (j + 1) ∧ coins2 (i + 1) (j + 1) ∧ (∀ i' j' : ℕ, ((i', j') ≠ (i, j) ∧ (i', j') ≠ (i + 1, j) ∧ (i', j') ≠ (i, j + 1) ∧ (i', j') ≠ (i + 1, j + 1)) → coins1 i' j' = coins2 i' j'))) -(legalseq : List (ℕ → ℕ → Bool) → Prop := (fun seq : List (ℕ → ℕ → Bool) => seq.length ≥ 1 ∧ seq[0]! = initcoins ∧ (∀ i < seq.length - 1, legalmove seq[i]! seq[i + 1]!))) +(legalseq : List (ℕ → ℕ → Bool) → Prop) +(hlegalseq : legalseq = (fun seq : List (ℕ → ℕ → Bool) => seq.length ≥ 1 ∧ seq[0]! = initcoins ∧ (∀ i < seq.length - 1, legalmove seq[i]! seq[i + 1]!))) (mnpos : m ≥ 1 ∧ n ≥ 1) : {config : ℕ → ℕ → Bool | ∃ seq : List (ℕ → ℕ → Bool), legalseq seq ∧ config = seq.getLast!}.encard = putnam_2023_b1_solution m n := sorry From 3658d1db1fa979c00cc6cb93188f64928ecd746d Mon Sep 17 00:00:00 2001 From: George Tsoukalas Date: Sat, 3 Aug 2024 16:01:05 +0000 Subject: [PATCH 2/4] Caught some stragglers. --- lean4/src/putnam_1971_b2.lean | 3 ++- lean4/src/putnam_1974_b6.lean | 3 ++- lean4/src/putnam_1980_b5.lean | 3 ++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/lean4/src/putnam_1971_b2.lean b/lean4/src/putnam_1971_b2.lean index a4c84b34..f70b6a7f 100644 --- a/lean4/src/putnam_1971_b2.lean +++ b/lean4/src/putnam_1971_b2.lean @@ -8,6 +8,7 @@ abbrev putnam_1971_b2_solution : Set (ℝ → ℝ) := sorry theorem putnam_1971_b2 (S : Set ℝ) (hS : S = univ \ {0, 1}) -(P : (ℝ → ℝ) → Prop := fun (F : ℝ → ℝ) => ∀ x ∈ S, F x + F ((x - 1)/x) = 1 + x) +(P : (ℝ → ℝ) → Prop) +(hP : P = fun (F : ℝ → ℝ) => ∀ x ∈ S, F x + F ((x - 1)/x) = 1 + x) : (∀ F ∈ putnam_1971_b2_solution, P F) ∧ ∀ f : ℝ → ℝ, P f → ∃ F ∈ putnam_1971_b2_solution, (∀ x ∈ S, f x = F x) := sorry diff --git a/lean4/src/putnam_1974_b6.lean b/lean4/src/putnam_1974_b6.lean index 9f5923e0..aabac694 100644 --- a/lean4/src/putnam_1974_b6.lean +++ b/lean4/src/putnam_1974_b6.lean @@ -6,7 +6,8 @@ open Set Nat Polynomial Filter Topology abbrev putnam_1974_b6_solution : (ℕ × ℕ × ℕ) := sorry -- ((2^1000 - 1)/3, (2^1000 - 1)/3, 1 + (2^1000 - 1)/3) theorem putnam_1974_b6 -(n : ℤ := 1000) +(n : ℤ) +(hn : n = 1000) (count0 count1 count2 : ℕ) (hcount0 : count0 = {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 0 [MOD 3]}.ncard) (hcount1 : count1 = {S | S ⊆ Finset.Icc 1 n ∧ S.card ≡ 1 [MOD 3]}.ncard) diff --git a/lean4/src/putnam_1980_b5.lean b/lean4/src/putnam_1980_b5.lean index b90c07a5..876e7fbf 100644 --- a/lean4/src/putnam_1980_b5.lean +++ b/lean4/src/putnam_1980_b5.lean @@ -6,7 +6,8 @@ open Set abbrev putnam_1980_b5_solution : ℝ → Prop := sorry -- fun t : ℝ => 1 ≥ t theorem putnam_1980_b5 -(T : Set ℝ := Icc 0 1) +(T : Set ℝ) +(hT : T = Icc 0 1) (P : ℝ → (ℝ → ℝ) → Prop) (Convex : (ℝ → ℝ) → Prop) (S : ℝ → Set (ℝ → ℝ)) From 75e315ee942e532fc8ca73b872a87c0999ea23a9 Mon Sep 17 00:00:00 2001 From: George Tsoukalas Date: Sat, 3 Aug 2024 16:01:27 +0000 Subject: [PATCH 3/4] Various notational improvements. --- lean4/src/putnam_1962_a4.lean | 2 -- lean4/src/putnam_1962_a5.lean | 2 -- lean4/src/putnam_1962_a6.lean | 2 -- lean4/src/putnam_1962_b1.lean | 2 -- lean4/src/putnam_1966_b1.lean | 2 +- lean4/src/putnam_1987_b5.lean | 3 +-- lean4/src/putnam_1991_a6.lean | 9 ++------- lean4/src/putnam_1996_a3.lean | 3 +-- lean4/src/putnam_1997_b5.lean | 2 -- lean4/src/putnam_2001_b2.lean | 3 +-- lean4/src/putnam_2001_b6.lean | 3 +-- lean4/src/putnam_2002_a3.lean | 3 +-- lean4/src/putnam_2006_b5.lean | 3 +-- lean4/src/putnam_2007_a2.lean | 4 +--- lean4/src/putnam_2007_a5.lean | 3 +-- lean4/src/putnam_2008_a6.lean | 2 +- lean4/src/putnam_2010_b1.lean | 3 ++- lean4/src/putnam_2010_b5.lean | 3 ++- lean4/src/putnam_2012_a5.lean | 2 +- lean4/src/putnam_2012_b1.lean | 2 +- lean4/src/putnam_2013_a3.lean | 2 +- lean4/src/putnam_2016_b5.lean | 3 ++- lean4/src/putnam_2020_a6.lean | 2 +- lean4/src/putnam_2022_b6.lean | 3 ++- lean4/src/putnam_2023_b4.lean | 6 +----- 25 files changed, 25 insertions(+), 49 deletions(-) diff --git a/lean4/src/putnam_1962_a4.lean b/lean4/src/putnam_1962_a4.lean index a92a7636..51d151f3 100644 --- a/lean4/src/putnam_1962_a4.lean +++ b/lean4/src/putnam_1962_a4.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open MeasureTheory - theorem putnam_1962_a4 (f : ℝ → ℝ) (a b : ℝ) diff --git a/lean4/src/putnam_1962_a5.lean b/lean4/src/putnam_1962_a5.lean index 4e196f4a..7ef238c4 100644 --- a/lean4/src/putnam_1962_a5.lean +++ b/lean4/src/putnam_1962_a5.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open MeasureTheory - abbrev putnam_1962_a5_solution : ℕ → ℕ := sorry -- fun n : ℕ => n * (n + 1) * 2^(n - 2) theorem putnam_1962_a5 diff --git a/lean4/src/putnam_1962_a6.lean b/lean4/src/putnam_1962_a6.lean index 455be60a..16a11578 100644 --- a/lean4/src/putnam_1962_a6.lean +++ b/lean4/src/putnam_1962_a6.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open MeasureTheory - theorem putnam_1962_a6 (S : Set ℚ) (hSadd : ∀ a ∈ S, ∀ b ∈ S, a + b ∈ S) diff --git a/lean4/src/putnam_1962_b1.lean b/lean4/src/putnam_1962_b1.lean index 84848da4..f461f42f 100644 --- a/lean4/src/putnam_1962_b1.lean +++ b/lean4/src/putnam_1962_b1.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open MeasureTheory - theorem putnam_1962_b1 (p : ℕ → ℝ → ℝ) (x y : ℝ) diff --git a/lean4/src/putnam_1966_b1.lean b/lean4/src/putnam_1966_b1.lean index 99b75543..0bc51bb2 100644 --- a/lean4/src/putnam_1966_b1.lean +++ b/lean4/src/putnam_1966_b1.lean @@ -1,7 +1,7 @@ import Mathlib open BigOperators -open Topology Filter +open Topology theorem putnam_1966_b1 (n : ℕ) diff --git a/lean4/src/putnam_1987_b5.lean b/lean4/src/putnam_1987_b5.lean index 534abf82..65b6cd8d 100644 --- a/lean4/src/putnam_1987_b5.lean +++ b/lean4/src/putnam_1987_b5.lean @@ -6,8 +6,7 @@ open MvPolynomial Real Nat Filter Topology theorem putnam_1987_b5 (n : ℕ) (npos : n > 0) -(O : Matrix (Fin 1) (Fin n) ℂ := 0) (M : Matrix (Fin (2 * n)) (Fin n) ℂ) -(hM : ∀ z : Matrix (Fin 1) (Fin (2 * n)) ℂ, z * M = O → (¬∀ i : Fin (2 * n), z 0 i = 0) → ∃ i : Fin (2 * n), (z 0 i).im ≠ 0) +(hM : ∀ z : Matrix (Fin 1) (Fin (2 * n)) ℂ, z * M = 0 → (¬∀ i : Fin (2 * n), z 0 i = 0) → ∃ i : Fin (2 * n), (z 0 i).im ≠ 0) : (∀ r : Matrix (Fin (2 * n)) (Fin 1) ℝ, ∃ w : Matrix (Fin n) (Fin 1) ℂ, ∀ i : (Fin (2 * n)), ((M * w) i 0).re = r i 0) := sorry diff --git a/lean4/src/putnam_1991_a6.lean b/lean4/src/putnam_1991_a6.lean index 9678cfe4..d255a7fa 100644 --- a/lean4/src/putnam_1991_a6.lean +++ b/lean4/src/putnam_1991_a6.lean @@ -6,13 +6,8 @@ open Filter Topology -- Note: uses (ℕ → ℕ) instead of (Fin r → ℕ) and (Fin s → ℕ) theorem putnam_1991_a6 (nabsum : ℕ → ℕ × (ℕ → ℕ) → Prop) -(agt : ℕ × (ℕ → ℕ) → Prop) -(A : ℕ → ℕ) -(bge : ℕ × (ℕ → ℕ) → Prop) -(g : ℕ → ℕ) -(bg1 : ℕ × (ℕ → ℕ) → Prop) -(bg2 : ℕ × (ℕ → ℕ) → Prop) -(B : ℕ → ℕ) +(agt bge bg1 bg2 : ℕ × (ℕ → ℕ) → Prop) +(A g B: ℕ → ℕ) (hnabsum : ∀ n ≥ 1, ∀ ab : ℕ × (ℕ → ℕ), nabsum n ab = (ab.1 ≥ 1 ∧ (∀ i < ab.1, ab.2 i > 0) ∧ (∀ i ≥ ab.1, ab.2 i = 0) ∧ (∑ i : Fin ab.1, ab.2 i) = n)) (hagt : ∀ a : ℕ × (ℕ → ℕ), agt a = (∀ i : Fin (a.1 - 2), a.2 i > a.2 (i + 1) + a.2 (i + 2)) ∧ a.2 (a.1 - 2) > a.2 (a.1 - 1)) (hA : ∀ n ≥ 1, A n = {a : ℕ × (ℕ → ℕ) | nabsum n a ∧ agt a}.encard) diff --git a/lean4/src/putnam_1996_a3.lean b/lean4/src/putnam_1996_a3.lean index 5a450a97..0337c7d3 100644 --- a/lean4/src/putnam_1996_a3.lean +++ b/lean4/src/putnam_1996_a3.lean @@ -4,6 +4,5 @@ open BigOperators abbrev putnam_1996_a3_solution : Prop := sorry -- False theorem putnam_1996_a3 -(student_choices : Finset.range 20 → Set (Finset.range 6)) -: putnam_1996_a3_solution ↔ ∃ S : Set (Finset.range 20), ∃ c1 c2 : Finset.range 6, c1 ≠ c2 ∧ S.ncard = 5 ∧ ({c1, c2} ⊆ ⋂ s ∈ S, student_choices s ∨ ({c1, c2} ⊆ ⋂ s ∈ S, (student_choices s)ᶜ)) := +: putnam_1996_a3_solution ↔ (∀ student_choices : Finset.range 20 → Set (Finset.range 6), ∃ S : Set (Finset.range 20), ∃ c1 c2 : Finset.range 6, c1 ≠ c2 ∧ S.ncard = 5 ∧ ({c1, c2} ⊆ ⋂ s ∈ S, student_choices s ∨ ({c1, c2} ⊆ ⋂ s ∈ S, (student_choices s)ᶜ))) := sorry diff --git a/lean4/src/putnam_1997_b5.lean b/lean4/src/putnam_1997_b5.lean index 0f5bcc79..c9e4eaa9 100644 --- a/lean4/src/putnam_1997_b5.lean +++ b/lean4/src/putnam_1997_b5.lean @@ -1,8 +1,6 @@ import Mathlib open BigOperators -open Filter Topology Bornology Set Polynomial - def tetration : ℕ → ℕ → ℕ | _, 0 => 1 | m, (n + 1) => m^(tetration m n) diff --git a/lean4/src/putnam_2001_b2.lean b/lean4/src/putnam_2001_b2.lean index 09197efa..50cf118f 100644 --- a/lean4/src/putnam_2001_b2.lean +++ b/lean4/src/putnam_2001_b2.lean @@ -7,8 +7,7 @@ abbrev putnam_2001_b2_solution : Set (ℝ × ℝ) := sorry -- {((3 ^ ((1 : ℝ) / 5) + 1) / 2, (3 ^ ((1 : ℝ) / 5) - 1) / 2)} theorem putnam_2001_b2 (x y : ℝ) -(eq1 : Prop) -(eq2 : Prop) +(eq1 eq2 : Prop) (heq1 : eq1 = (1 / x + 1 / (2 * y) = (x ^ 2 + 3 * y ^ 2) * (3 * x ^ 2 + y ^ 2))) (heq2 : eq2 = (1 / x - 1 / (2 * y) = 2 * (y ^ 4 - x ^ 4))) : (eq1 ∧ eq2) ↔ (x, y) ∈ putnam_2001_b2_solution := diff --git a/lean4/src/putnam_2001_b6.lean b/lean4/src/putnam_2001_b6.lean index c6c13bd2..64ddb0a1 100644 --- a/lean4/src/putnam_2001_b6.lean +++ b/lean4/src/putnam_2001_b6.lean @@ -7,8 +7,7 @@ open Topology Filter Polynomial Set abbrev putnam_2001_b6_solution : Prop := sorry -- True theorem putnam_2001_b6 -(aposinc : (ℤ → ℝ) → Prop) -(alim : (ℤ → ℝ) → Prop) +(aposinc alim : (ℤ → ℝ) → Prop) (haposinc : ∀ a : ℤ → ℝ, aposinc a = ∀ n ≥ 1, a n > 0 ∧ a n < a (n + 1)) (halim : ∀ a : ℤ → ℝ, alim a = Tendsto (fun n : ℤ => a (n + 1) / (n + 1)) atTop (𝓝 0)) : (∀ a : ℤ → ℝ, (aposinc a ∧ alim a) → {n : ℤ | n > 0 ∧ (∀ i ∈ Set.Icc 1 (n - 1), a (n - i) + a (n + i) < 2 * a n)}.Infinite) ↔ putnam_2001_b6_solution := diff --git a/lean4/src/putnam_2002_a3.lean b/lean4/src/putnam_2002_a3.lean index f5706245..5cc3d9b2 100644 --- a/lean4/src/putnam_2002_a3.lean +++ b/lean4/src/putnam_2002_a3.lean @@ -4,9 +4,8 @@ open BigOperators open Nat theorem putnam_2002_a3 -(n : ℤ) +(n Tn : ℤ) (hn : n ≥ 2) -(Tn : ℤ) (hTn : Tn = Set.ncard {S : Set ℤ | S ⊆ Set.Icc 1 n ∧ Nonempty S ∧ ∃ k : ℤ, k = ((1 : ℝ) / S.ncard) * (∑' s : S, s.1)}) : Even (Tn - n) := sorry diff --git a/lean4/src/putnam_2006_b5.lean b/lean4/src/putnam_2006_b5.lean index 54ba3f6b..de4196f4 100644 --- a/lean4/src/putnam_2006_b5.lean +++ b/lean4/src/putnam_2006_b5.lean @@ -6,8 +6,7 @@ open Set noncomputable abbrev putnam_2006_b5_solution : ℝ := sorry -- 1 / 16 theorem putnam_2006_b5 -(I : (ℝ → ℝ) → ℝ) -(J : (ℝ → ℝ) → ℝ) +(I J : (ℝ → ℝ) → ℝ) (hI : I = fun f ↦ ∫ x in (0)..1, x ^ 2 * (f x)) (hJ : J = fun f ↦ ∫ x in (0)..1, x * (f x) ^ 2) (max : ℝ) diff --git a/lean4/src/putnam_2007_a2.lean b/lean4/src/putnam_2007_a2.lean index e3e76eca..ab9ae117 100644 --- a/lean4/src/putnam_2007_a2.lean +++ b/lean4/src/putnam_2007_a2.lean @@ -4,9 +4,7 @@ open BigOperators noncomputable abbrev putnam_2007_a2_solution : ENNReal := sorry -- 4 theorem putnam_2007_a2 -(Sinterpos : Set (Fin 2 → ℝ) → Prop) -(Sinterneg : Set (Fin 2 → ℝ) → Prop) -(Sconv : Set (Fin 2 → ℝ) → Prop) +(Sinterpos Sinterneg Sconv : Set (Fin 2 → ℝ) → Prop) (hSinterpos : ∀ S : Set (Fin 2 → ℝ), Sinterpos S = ((∃ p ∈ S, p 0 > 0 ∧ p 1 > 0 ∧ p 0 * p 1 = 1) ∧ (∃ p ∈ S, p 0 < 0 ∧ p 1 < 0 ∧ p 0 * p 1 = 1))) (hSinterneg : ∀ S : Set (Fin 2 → ℝ), Sinterneg S = ((∃ p ∈ S, p 0 < 0 ∧ p 1 > 0 ∧ p 0 * p 1 = -1) ∧ (∃ p ∈ S, p 0 > 0 ∧ p 1 < 0 ∧ p 0 * p 1 = -1))) (hSconv : ∀ S : Set (Fin 2 → ℝ), Sconv S = (Convex ℝ S ∧ Sinterpos S ∧ Sinterneg S)) diff --git a/lean4/src/putnam_2007_a5.lean b/lean4/src/putnam_2007_a5.lean index 5aed446f..10ca2727 100644 --- a/lean4/src/putnam_2007_a5.lean +++ b/lean4/src/putnam_2007_a5.lean @@ -5,8 +5,7 @@ open Set Nat theorem putnam_2007_a5 (G : Type*) [Group G] [Fintype G] -(p : ℕ) -(n : ℕ) +(p n : ℕ) (hp : Nat.Prime p) (hn : n = {g : G | orderOf g = p}.encard) : n = 0 ∨ p ∣ (n + 1) := diff --git a/lean4/src/putnam_2008_a6.lean b/lean4/src/putnam_2008_a6.lean index 09dd52f2..2e1b783a 100644 --- a/lean4/src/putnam_2008_a6.lean +++ b/lean4/src/putnam_2008_a6.lean @@ -4,5 +4,5 @@ open BigOperators open Filter Topology Set theorem putnam_2008_a6 -: (∃ c : ℝ, c > 0 ∧ ∀ G [Group G] (fing : Fintype G), fing.card > 1 → ∃ s : List G, s.length ≤ c * Real.log (fing.card : ℝ) ∧ ∀ g : G, ∃ t : List G, t.Sublist s ∧ t.prod = g) := +: ∃ c : ℝ, c > 0 ∧ ∀ G [Group G] (fing : Fintype G), fing.card > 1 → ∃ s : List G, s.length ≤ c * Real.log (fing.card : ℝ) ∧ ∀ g : G, ∃ t : List G, t.Sublist s ∧ t.prod = g := sorry diff --git a/lean4/src/putnam_2010_b1.lean b/lean4/src/putnam_2010_b1.lean index 41ee6ea4..2eaf2ee5 100644 --- a/lean4/src/putnam_2010_b1.lean +++ b/lean4/src/putnam_2010_b1.lean @@ -5,5 +5,6 @@ open Filter Topology Set abbrev putnam_2010_b1_solution : Prop := sorry -- False -theorem putnam_2010_b1 : (∃ a : ℕ → ℝ, ∀ m : ℕ, m > 0 → ∑' i : ℕ, (a i)^m = m) ↔ putnam_2010_b1_solution := +theorem putnam_2010_b1 +: (∃ a : ℕ → ℝ, ∀ m : ℕ, m > 0 → ∑' i : ℕ, (a i)^m = m) ↔ putnam_2010_b1_solution := sorry diff --git a/lean4/src/putnam_2010_b5.lean b/lean4/src/putnam_2010_b5.lean index fc68cb4a..bf6dd305 100644 --- a/lean4/src/putnam_2010_b5.lean +++ b/lean4/src/putnam_2010_b5.lean @@ -5,5 +5,6 @@ open Filter Topology Set abbrev putnam_2010_b5_solution : Prop := sorry -- False -theorem putnam_2010_b5 : (∃ f : ℝ → ℝ, StrictMono f ∧ Differentiable ℝ f ∧ (∀ x : ℝ, deriv f x = f (f x))) ↔ putnam_2010_b5_solution := +theorem putnam_2010_b5 +: (∃ f : ℝ → ℝ, StrictMono f ∧ Differentiable ℝ f ∧ (∀ x : ℝ, deriv f x = f (f x))) ↔ putnam_2010_b5_solution := sorry diff --git a/lean4/src/putnam_2012_a5.lean b/lean4/src/putnam_2012_a5.lean index a9f9ad1f..ef8ff947 100644 --- a/lean4/src/putnam_2012_a5.lean +++ b/lean4/src/putnam_2012_a5.lean @@ -11,7 +11,7 @@ theorem putnam_2012_a5 (hp : Nat.Prime p) {F : Type*} [Field F] [Fintype F] (hK : Fintype.card F = p) -(G : Matrix (Fin n) (Fin n) F → (Fin n → F) → (Fin n → F) → (Fin n → F)) +(G : Matrix (Fin n) (Fin n) F → (Fin n → F) → (Fin n → F) → (Fin n → F)) (hG : ∀ M : Matrix (Fin n) (Fin n) F, ∀ v x : (Fin n → F), G M v x = v + mulVec M x) : (n, p) ∈ putnam_2012_a5_solution ↔ ∃ M : Matrix (Fin n) (Fin n) F, diff --git a/lean4/src/putnam_2012_b1.lean b/lean4/src/putnam_2012_b1.lean index 3dd324b6..a03842cd 100644 --- a/lean4/src/putnam_2012_b1.lean +++ b/lean4/src/putnam_2012_b1.lean @@ -8,7 +8,7 @@ theorem putnam_2012_b1 (rngS : ∀ f ∈ S, ∀ x : Set.Ici (0 : ℝ), f x ∈ Set.Ici (0 : ℝ)) (f1 : Set.Ici (0 : ℝ) → ℝ) (hf1 : f1 = fun (x : Set.Ici (0 : ℝ)) ↦ exp x - 1) -(f2 : Set.Ici (0 : ℝ) → ℝ ) +(f2 : Set.Ici (0 : ℝ) → ℝ) (hf2 : f2 = fun (x : Set.Ici (0 : ℝ)) ↦ Real.log (x + 1)) (hf1mem : f1 ∈ S) (hf2mem : f2 ∈ S) diff --git a/lean4/src/putnam_2013_a3.lean b/lean4/src/putnam_2013_a3.lean index 667ffd27..6531869a 100644 --- a/lean4/src/putnam_2013_a3.lean +++ b/lean4/src/putnam_2013_a3.lean @@ -8,6 +8,6 @@ theorem putnam_2013_a3 (a : Set.Icc 0 n → ℝ) (x : ℝ) (hx : 0 < x ∧ x < 1) -(hsum: (∑ i : Set.Icc 0 n, a i / (1 - x ^ (i.1 + 1))) = 0) +(hsum : (∑ i : Set.Icc 0 n, a i / (1 - x ^ (i.1 + 1))) = 0) : ∃ y : ℝ, 0 < y ∧ y < 1 ∧ (∑ i : Set.Icc 0 n, a i * y ^ i.1) = 0 := sorry diff --git a/lean4/src/putnam_2016_b5.lean b/lean4/src/putnam_2016_b5.lean index 33274481..f6ecb1f2 100644 --- a/lean4/src/putnam_2016_b5.lean +++ b/lean4/src/putnam_2016_b5.lean @@ -9,4 +9,5 @@ theorem putnam_2016_b5 (f : Set.Ioi (1 : ℝ) → Set.Ioi (1 : ℝ)) (fle : Prop) (hfle : fle = ∀ x y : Set.Ioi (1 : ℝ), ((x : ℝ) ^ 2 ≤ y ∧ y ≤ (x : ℝ) ^ 3) → ((f x : ℝ) ^ 2 ≤ f y ∧ f y ≤ (f x : ℝ) ^ 3)) -: fle ↔ f ∈ putnam_2016_b5_solution := sorry +: fle ↔ f ∈ putnam_2016_b5_solution := +sorry diff --git a/lean4/src/putnam_2020_a6.lean b/lean4/src/putnam_2020_a6.lean index 38b77921..ea94bd77 100644 --- a/lean4/src/putnam_2020_a6.lean +++ b/lean4/src/putnam_2020_a6.lean @@ -7,7 +7,7 @@ noncomputable abbrev putnam_2020_a6_solution : ℝ := sorry -- Real.pi / 4 theorem putnam_2020_a6 (f : ℤ → (ℝ → ℝ)) -(hf : f = fun N : ℤ => fun x : ℝ => +(hf : f = fun N : ℤ => fun x : ℝ => ∑ n in Finset.Icc 0 N, (N + 1/2 - n)/((N + 1)*(2*n + 1)) * Real.sin ((2*n + 1)*x)) : (∀ N > 0, ∀ x : ℝ, f N x ≤ putnam_2020_a6_solution) ∧ ∀ M : ℝ, (∀ N > 0, ∀ x : ℝ, f N x ≤ M) → M ≥ putnam_2020_a6_solution := diff --git a/lean4/src/putnam_2022_b6.lean b/lean4/src/putnam_2022_b6.lean index f051dc01..1d9a5633 100644 --- a/lean4/src/putnam_2022_b6.lean +++ b/lean4/src/putnam_2022_b6.lean @@ -10,4 +10,5 @@ theorem putnam_2022_b6 (f : Set.Ioi (0 : ℝ) → Set.Ioi (0 : ℝ)) (eq : Prop) (heq : eq = ∃ fr : ℝ → ℝ, (∀ x : Set.Ioi (0 : ℝ), fr x = f x) ∧ (∀ x y : Set.Ioi (0 : ℝ), fr (x * fr y) + fr (y * fr x) = 1 + fr (x + y))) -: (Continuous f ∧ eq) ↔ f ∈ putnam_2022_b6_solution := sorry +: (Continuous f ∧ eq) ↔ f ∈ putnam_2022_b6_solution := +sorry diff --git a/lean4/src/putnam_2023_b4.lean b/lean4/src/putnam_2023_b4.lean index f5782d6a..a6bae969 100644 --- a/lean4/src/putnam_2023_b4.lean +++ b/lean4/src/putnam_2023_b4.lean @@ -8,11 +8,7 @@ abbrev putnam_2023_b4_solution : ℝ := sorry -- 29 theorem putnam_2023_b4 (tne : ℕ → (ℕ → ℝ) → Set ℝ) -(fdiff : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) -(flim : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) -(fderiv1 : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) -(fderiv2 : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) -(fall : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) +(fdiff flim fderiv1 fderiv2 fall : ℕ → (ℕ → ℝ) → (ℝ → ℝ) → Prop) (tinc : ℕ → (ℕ → ℝ) → Prop) (Tall : ℝ → Prop) (htne : ∀ n : ℕ, ∀ ts : ℕ → ℝ, tne n ts = {t : ℝ | t > ts 0 ∧ ∀ i : Fin n, t ≠ ts (i.1 + 1)}) From bc1e4d98922709b6edcfc73c07979c7de7ea774e Mon Sep 17 00:00:00 2001 From: George Tsoukalas Date: Sun, 4 Aug 2024 13:26:25 +0000 Subject: [PATCH 4/4] Modified pi definition with open Real. --- lean4/src/putnam_1962_b6.lean | 4 +--- lean4/src/putnam_1965_a1.lean | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/lean4/src/putnam_1962_b6.lean b/lean4/src/putnam_1962_b6.lean index 808f4d76..7cbd119a 100644 --- a/lean4/src/putnam_1962_b6.lean +++ b/lean4/src/putnam_1962_b6.lean @@ -1,11 +1,9 @@ import Mathlib open BigOperators -open MeasureTheory +open MeasureTheory Real theorem putnam_1962_b6 -(π : ℝ) -(hπ : π = Real.pi) (n : ℕ) (a b : ℕ → ℝ) (xs : Set ℝ) diff --git a/lean4/src/putnam_1965_a1.lean b/lean4/src/putnam_1965_a1.lean index 3722ff96..5096c311 100644 --- a/lean4/src/putnam_1965_a1.lean +++ b/lean4/src/putnam_1965_a1.lean @@ -1,13 +1,11 @@ import Mathlib open BigOperators -open EuclideanGeometry +open EuclideanGeometry Real noncomputable abbrev putnam_1965_a1_solution : ℝ := sorry -- Real.pi / 15 theorem putnam_1965_a1 -(π : ℝ) -(hπ : π = Real.pi) (A B C X Y : EuclideanSpace ℝ (Fin 2)) (hABC : ¬Collinear ℝ {A, B, C}) (hangles : ∠ C A B < ∠ B C A ∧ ∠ B C A < π/2 ∧ π/2 < ∠ A B C)