url stringclasses 147 values | commit stringclasses 147 values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum_2d | [487, 1] | [517, 29] | simp only [Pi.zero_apply, div_pow] | case hf.hg'
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
w0m : Complex.abs w0 < r
w1m : Complex.abs w1 < r
n : ℕ
⊢ 0 n ≤ (Complex.abs w0 / r) ^ n | case hf.hg'
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
w0m : Complex.abs w0 < r
w1m : Complex.abs w1 < r
n : ℕ
⊢ 0 ≤ Complex.abs w0 ^ n / r ^ n | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hg'
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
w0m : Complex.abs w0 < r
w1m : Complex.abs w1 < r
n : ℕ
⊢ 0 n ≤ (Complex.abs w0 / r) ^ n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum_2d | [487, 1] | [517, 29] | bound | case hf.hg'
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
w0m : Complex.abs w0 < r
w1m : Complex.abs w1 < r
n : ℕ
⊢ 0 ≤ Complex.abs w0 ^ n / r ^ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hf.hg'
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
w0m : Complex.abs w0 < r
w1m : Complex.abs w1 < r
n : ℕ
⊢ 0 ≤ Complex.abs w0 ^ n / r ^ n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum_2d | [487, 1] | [517, 29] | rw [← ha'] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
sf : Summable f
⊢ HasSum f a' | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
sf : Summable f
⊢ HasSum f (∑' (n : ℕ × ℕ), f n) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
sf : Summable f
⊢ HasSum f a'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum_2d | [487, 1] | [517, 29] | exact sf.hasSum | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
sf : Summable f
⊢ HasSum f (∑' (n : ℕ × ℕ), f n) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f✝ c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
ha : f✝ (c0 + w0, c1 + w1) = a
f : ℕ × ℕ → E
hf : (fun n => w0 ^ n.2 • w1 ^ n.1 • h.series2Coeff n.2 n.1) = f
g : ℕ → E
hg : (fun n1 => w1 ^ n1 • h.series2CoeffN0Sum n1 w0) = g
a' : E
ha' : ∑' (n : ℕ × ℕ), f n = a'
gs : HasSum g a
fs : ∀ (n1 : ℕ), HasSum (fun n0 => f (n1, n0)) (g n1)
fb : ∀ (n : ℕ × ℕ), ‖f n‖ ≤ b * (Complex.abs w0 / r) ^ n.2 * (Complex.abs w1 / r) ^ n.1
sf : Summable f
⊢ HasSum f (∑' (n : ℕ × ℕ), f n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | generalize hg : (fun n ↦ (Finset.range (n + 1)).sum fun n1 ↦ f (n1, n - n1)) = g | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum f a
⊢ HasSum (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum f a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum f a
⊢ HasSum (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | rw [←Finset.sigmaAntidiagonalEquivProd.hasSum_iff] at h | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum f a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum f a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | have fg : ∀ n, HasSum (fun d : Finset.antidiagonal n ↦
(f ∘ Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n) := by
intro n; simp only [Function.comp_apply, Finset.sigmaAntidiagonalEquivProd_apply]
have fs := hasSum_fintype fun d : ↥(Finset.antidiagonal n) ↦ f ↑d
have e : (Finset.univ.sum fun d : ↥(Finset.antidiagonal n) ↦ f ↑d) = g n := by
rw [Finset.sum_coe_sort, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk, ← hg]
rwa [← e] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
fg : ∀ (n : ℕ), HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n)
⊢ HasSum g a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ HasSum g a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | exact HasSum.sigma h fg | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
fg : ∀ (n : ℕ), HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n)
⊢ HasSum g a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
fg : ∀ (n : ℕ), HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n)
⊢ HasSum g a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | intro n | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ ∀ (n : ℕ), HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
⊢ ∀ (n : ℕ), HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | simp only [Function.comp_apply, Finset.sigmaAntidiagonalEquivProd_apply] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => f ↑d) (g n) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) ⟨n, d⟩) (g n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | have fs := hasSum_fintype fun d : ↥(Finset.antidiagonal n) ↦ f ↑d | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => f ↑d) (g n) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
⊢ HasSum (fun d => f ↑d) (g n) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
⊢ HasSum (fun d => f ↑d) (g n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | have e : (Finset.univ.sum fun d : ↥(Finset.antidiagonal n) ↦ f ↑d) = g n := by
rw [Finset.sum_coe_sort, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk, ← hg] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
⊢ HasSum (fun d => f ↑d) (g n) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
e : (Finset.univ.sum fun d => f ↑d) = g n
⊢ HasSum (fun d => f ↑d) (g n) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
⊢ HasSum (fun d => f ↑d) (g n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | rwa [← e] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
e : (Finset.univ.sum fun d => f ↑d) = g n
⊢ HasSum (fun d => f ↑d) (g n) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
e : (Finset.univ.sum fun d => f ↑d) = g n
⊢ HasSum (fun d => f ↑d) (g n)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | HasSum.antidiagonal_of_2d | [520, 1] | [532, 26] | rw [Finset.sum_coe_sort, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk, ← hg] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
⊢ (Finset.univ.sum fun d => f ↑d) = g n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
f : ℕ × ℕ → E
a : E
h : HasSum (f ∘ ⇑Finset.sigmaAntidiagonalEquivProd) a
g : ℕ → E
hg : (fun n => (Finset.range (n + 1)).sum fun n1 => f (n1, n - n1)) = g
n : ℕ
fs : HasSum (fun d => f ↑d) (Finset.univ.sum fun b => f ↑b)
⊢ (Finset.univ.sum fun d => f ↑d) = g n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | have sum := (cauchy2_hasSum_2d h w0m w1m).antidiagonal_of_2d | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1)) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum
(fun n =>
(Finset.range (n + 1)).sum fun n1 =>
w0 ^ (n1, n - n1).2 • w1 ^ (n1, n - n1).1 • h.series2Coeff (n1, n - n1).2 (n1, n - n1).1)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1)) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | simp only [ge_iff_le] at sum | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum
(fun n =>
(Finset.range (n + 1)).sum fun n1 =>
w0 ^ (n1, n - n1).2 • w1 ^ (n1, n - n1).1 • h.series2Coeff (n1, n - n1).2 (n1, n - n1).1)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1)) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1)) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum
(fun n =>
(Finset.range (n + 1)).sum fun n1 =>
w0 ^ (n1, n - n1).2 • w1 ^ (n1, n - n1).1 • h.series2Coeff (n1, n - n1).2 (n1, n - n1).1)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | generalize ha : f (c0 + w0, c1 + w1) = a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1)) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
a : E
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f (c0 + w0, c1 + w1))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | rw [ha] at sum | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
a : E
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
sum :
HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x)
(f (c0 + w0, c1 + w1))
a : E
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | clear ha | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
ha : f (c0 + w0, c1 + w1) = a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | have e : (fun n ↦
(Finset.range (n + 1)).sum fun n1 ↦ w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
fun n ↦ series2 h n fun _ : Fin n ↦ (w0, w1) := by
clear sum; funext n
rw [series2]; simp only [ge_iff_le, ContinuousMultilinearMap.sum_apply]
simp_rw [termCmmap_apply]
nth_rw 1 [← Finset.sum_range_reflect]; simp
apply Finset.sum_congr rfl
intro n0 n0n'; simp only [Finset.mem_range] at n0n'
have n0n := Nat.le_of_lt_succ n0n'
rw [Nat.sub_sub_self n0n, min_eq_left n0n] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
e :
(fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1)
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | rwa [←e] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
e :
(fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1)
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
e :
(fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1)
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | clear sum | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
⊢ (fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
⊢ (fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
sum : HasSum (fun n => (Finset.range (n + 1)).sum fun x => w0 ^ (n - x) • w1 ^ x • h.series2Coeff (n - x) x) a
⊢ (fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | funext n | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
⊢ (fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(series2 h n) fun x => (w0, w1) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
⊢ (fun n => (Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) = fun n =>
(series2 h n) fun x => (w0, w1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | rw [series2] | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(series2 h n) fun x => (w0, w1) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
((Finset.range (n + 1)).sum fun n0 => termCmmap ℂ n n0 (h.series2Coeff n0 (n - n0))) fun x => (w0, w1) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(series2 h n) fun x => (w0, w1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | simp only [ge_iff_le, ContinuousMultilinearMap.sum_apply] | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
((Finset.range (n + 1)).sum fun n0 => termCmmap ℂ n n0 (h.series2Coeff n0 (n - n0))) fun x => (w0, w1) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun a => (termCmmap ℂ n a (h.series2Coeff a (n - a))) fun x => (w0, w1) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
((Finset.range (n + 1)).sum fun n0 => termCmmap ℂ n n0 (h.series2Coeff n0 (n - n0))) fun x => (w0, w1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | simp_rw [termCmmap_apply] | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun a => (termCmmap ℂ n a (h.series2Coeff a (n - a))) fun x => (w0, w1) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun a => (termCmmap ℂ n a (h.series2Coeff a (n - a))) fun x => (w0, w1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | nth_rw 1 [← Finset.sum_range_reflect] | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun j =>
w0 ^ (n - (n + 1 - 1 - j)) • w1 ^ (n + 1 - 1 - j) • h.series2Coeff (n - (n + 1 - 1 - j)) (n + 1 - 1 - j)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun n1 => w0 ^ (n - n1) • w1 ^ n1 • h.series2Coeff (n - n1) n1) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | simp | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun j =>
w0 ^ (n - (n + 1 - 1 - j)) • w1 ^ (n + 1 - 1 - j) • h.series2Coeff (n - (n + 1 - 1 - j)) (n + 1 - 1 - j)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun x => w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun j =>
w0 ^ (n - (n + 1 - 1 - j)) • w1 ^ (n + 1 - 1 - j) • h.series2Coeff (n - (n + 1 - 1 - j)) (n + 1 - 1 - j)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | apply Finset.sum_congr rfl | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun x => w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ∀ x ∈ Finset.range (n + 1),
w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x) =
w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ((Finset.range (n + 1)).sum fun x => w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x)) =
(Finset.range (n + 1)).sum fun x => w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | intro n0 n0n' | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ∀ x ∈ Finset.range (n + 1),
w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x) =
w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 ∈ Finset.range (n + 1)
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n : ℕ
⊢ ∀ x ∈ Finset.range (n + 1),
w0 ^ (n - (n - x)) • w1 ^ (n - x) • h.series2Coeff (n - (n - x)) (n - x) =
w0 ^ min x n • w1 ^ (n - x) • h.series2Coeff x (n - x)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | simp only [Finset.mem_range] at n0n' | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 ∈ Finset.range (n + 1)
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 ∈ Finset.range (n + 1)
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | have n0n := Nat.le_of_lt_succ n0n' | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
n0n : n0 ≤ n
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | cauchy2_hasSum | [535, 1] | [551, 11] | rw [Nat.sub_sub_self n0n, min_eq_left n0n] | case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
n0n : n0 ≤ n
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
a : E
n n0 : ℕ
n0n' : n0 < n + 1
n0n : n0 ≤ n
⊢ w0 ^ (n - (n - n0)) • w1 ^ (n - n0) • h.series2Coeff (n - (n - n0)) (n - n0) =
w0 ^ min n0 n • w1 ^ (n - n0) • h.series2Coeff n0 (n - n0)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | simp | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ 0 < ENNReal.ofReal r | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ 0 < r | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ 0 < ENNReal.ofReal r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | exact h.rp | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ 0 < r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ 0 < r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | simp only [Metric.emetric_ball, Metric.mem_ball, dist_zero_right, Prod.forall] | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ ∀ {y : ℂ × ℂ}, y ∈ EMetric.ball 0 (ENNReal.ofReal r) → HasSum (fun n => (series2 h n) fun x => y) (f ((c0, c1) + y)) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ ∀ (a b_1 : ℂ), ‖(a, b_1)‖ < r → HasSum (fun n => (series2 h n) fun x => (a, b_1)) (f ((c0, c1) + (a, b_1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ ∀ {y : ℂ × ℂ}, y ∈ EMetric.ball 0 (ENNReal.ofReal r) → HasSum (fun n => (series2 h n) fun x => y) (f ((c0, c1) + y))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | intro w0 w1 wr | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ ∀ (a b_1 : ℂ), ‖(a, b_1)‖ < r → HasSum (fun n => (series2 h n) fun x => (a, b_1)) (f ((c0, c1) + (a, b_1))) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : ‖(w0, w1)‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0 w1 : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
⊢ ∀ (a b_1 : ℂ), ‖(a, b_1)‖ < r → HasSum (fun n => (series2 h n) fun x => (a, b_1)) (f ((c0, c1) + (a, b_1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | rw [Prod.norm_def] at wr | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : ‖(w0, w1)‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : max ‖(w0, w1).1‖ ‖(w0, w1).2‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : ‖(w0, w1)‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | simp only [Complex.norm_eq_abs, ge_iff_le, max_lt_iff] at wr | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : max ‖(w0, w1).1‖ ‖(w0, w1).2‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : max ‖(w0, w1).1‖ ‖(w0, w1).2‖ < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | have w0m : w0 ∈ ball (0 : ℂ) r := by simp; exact wr.left | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | have w1m : w1 ∈ ball (0 : ℂ) r := by simp; exact wr.right | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | exact cauchy2_hasSum h w0m w1m | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1))) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
w1m : w1 ∈ ball 0 r
⊢ HasSum (fun n => (series2 h n) fun x => (w0, w1)) (f ((c0, c1) + (w0, w1)))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | simp | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ w0 ∈ ball 0 r | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ Complex.abs w0 < r | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ w0 ∈ ball 0 r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | exact wr.left | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ Complex.abs w0 < r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
⊢ Complex.abs w0 < r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | simp | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ w1 ∈ ball 0 r | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ Complex.abs w1 < r | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ w1 ∈ ball 0 r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_h | [554, 1] | [564, 39] | exact wr.right | E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ Complex.abs w1 < r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
c0 c1 w0✝ w1✝ : ℂ
r b : ℝ
h : Separate f c0 c1 r b s
w0 w1 : ℂ
wr : Complex.abs w0 < r ∧ Complex.abs w1 < r
w0m : w0 ∈ ball 0 r
⊢ Complex.abs w1 < r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | intro c cs | E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
⊢ AnalyticOn ℂ f s | E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
⊢ AnalyticOn ℂ f s
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | rcases Metric.isOpen_iff.mp o c cs with ⟨r, rp, rs⟩ | E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
⊢ AnalyticAt ℂ f c | case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs : ball c r ⊆ s
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | have rs : closedBall c (r / 2) ⊆ s := le_trans (Metric.closedBall_subset_ball (by linarith)) rs | case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs : ball c r ⊆ s
⊢ AnalyticAt ℂ f c | case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs : ball c r ⊆ s
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | rcases ((isCompact_closedBall _ _).bddAbove_image (ContinuousOn.mono fc rs).norm).exists_ge 0
with ⟨b, bp, bh⟩ | case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
⊢ AnalyticAt ℂ f c | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ y ∈ (fun x => ‖f x‖) '' closedBall c (r / 2), y ≤ b
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | simp only [Set.forall_mem_image] at bh | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ y ∈ (fun x => ‖f x‖) '' closedBall c (r / 2), y ≤ b
⊢ AnalyticAt ℂ f c | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ y ∈ (fun x => ‖f x‖) '' closedBall c (r / 2), y ≤ b
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | have h : Separate f c.fst c.snd (r / 2) b s :=
{ rp := by linarith
so := o
rs := rs
fc := fc
fa0 := fa0 _ _
fa1 := fa1 _ _
bp := bp
fb := fun {z0 z1} z0m z1m ↦ @bh (z0, z1)
(spheres_subset_closedBall (Set.mk_mem_prod z0m z1m)) } | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
⊢ AnalyticAt ℂ f c | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | have a := (osgood_h h).analyticAt | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
⊢ AnalyticAt ℂ f c | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
a : AnalyticAt ℂ f (c.1, c.2)
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | simpa only [Prod.mk.eta] using a | case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
a : AnalyticAt ℂ f (c.1, c.2)
⊢ AnalyticAt ℂ f c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
h : Separate f c.1 c.2 (r / 2) b s
a : AnalyticAt ℂ f (c.1, c.2)
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | linarith | E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs : ball c r ⊆ s
⊢ r / 2 < r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs : ball c r ⊆ s
⊢ r / 2 < r
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood | [570, 1] | [592, 35] | linarith | E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
⊢ 0 < r / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
f : ℂ × ℂ → E
s : Set (ℂ × ℂ)
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
o : IsOpen s
fc : ContinuousOn f s
fa0 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z0 => f (z0, z1)) z0
fa1 : ∀ (z0 z1 : ℂ), (z0, z1) ∈ s → AnalyticAt ℂ (fun z1 => f (z0, z1)) z1
c : ℂ × ℂ
cs : c ∈ s
r : ℝ
rp : r > 0
rs✝ : ball c r ⊆ s
rs : closedBall c (r / 2) ⊆ s
b : ℝ
bp : 0 ≤ b
bh : ∀ ⦃x : ℂ × ℂ⦄, x ∈ closedBall c (r / 2) → ‖f x‖ ≤ b
⊢ 0 < r / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_at' | [596, 1] | [603, 35] | rcases eventually_nhds_iff.mp h with ⟨s, h, o, cs⟩ | E : Type
f : ℂ × ℂ → E
c : ℂ × ℂ
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
h :
∀ᶠ (x : ℂ × ℂ) in 𝓝 c,
ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
⊢ AnalyticAt ℂ f c | case intro.intro.intro
E : Type
f : ℂ × ℂ → E
c : ℂ × ℂ
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
h✝ :
∀ᶠ (x : ℂ × ℂ) in 𝓝 c,
ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
s : Set (ℂ × ℂ)
h : ∀ x ∈ s, ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
o : IsOpen s
cs : c ∈ s
⊢ AnalyticAt ℂ f c | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
f : ℂ × ℂ → E
c : ℂ × ℂ
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
h :
∀ᶠ (x : ℂ × ℂ) in 𝓝 c,
ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Hartogs/Osgood.lean | osgood_at' | [596, 1] | [603, 35] | exact osgood o (fun _ m ↦ (h _ m).1.continuousWithinAt) (fun _ _ m ↦ (h _ m).2.1)
(fun _ _ m ↦ (h _ m).2.2) c cs | case intro.intro.intro
E : Type
f : ℂ × ℂ → E
c : ℂ × ℂ
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
h✝ :
∀ᶠ (x : ℂ × ℂ) in 𝓝 c,
ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
s : Set (ℂ × ℂ)
h : ∀ x ∈ s, ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
o : IsOpen s
cs : c ∈ s
⊢ AnalyticAt ℂ f c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
E : Type
f : ℂ × ℂ → E
c : ℂ × ℂ
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
h✝ :
∀ᶠ (x : ℂ × ℂ) in 𝓝 c,
ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
s : Set (ℂ × ℂ)
h : ∀ x ∈ s, ContinuousAt f x ∧ AnalyticAt ℂ (fun z => f (z, x.2)) x.1 ∧ AnalyticAt ℂ (fun z => f (x.1, z)) x.2
o : IsOpen s
cs : c ∈ s
⊢ AnalyticAt ℂ f c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | induction x | α β : Type
x y : Color α
⊢ x = y ↔ x.r = y.r ∧ x.g = y.g ∧ x.b = y.b ∧ x.a = y.a | case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x y : Color α
⊢ x = y ↔ x.r = y.r ∧ x.g = y.g ∧ x.b = y.b ∧ x.a = y.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | induction y | case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a | case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | simp only [mk.injEq] | case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | rw [unquantize] at n ⊢ | α β : Type
v : UInt8
n : v.unquantize ≠ nan
⊢ v.unquantize.val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : v.unquantize ≠ nan
⊢ v.unquantize.val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have lt : 2 * v.toNat + 1 < 2^63 := by have h := v.toNat_lt; norm_num only at h ⊢; omega | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have e9 : ((-9 : Int64) : ℤ) = -9 := by decide | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | simp only [Floating.val_scaleB n, Floating.val_ofNat' lt, e9, Nat.cast_add, Nat.cast_mul,
Nat.cast_ofNat, Nat.cast_one, Int.reduceNeg, zpow_neg, add_mul, one_mul, one_div] | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹ | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | ring_nf | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have h := v.toNat_lt | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ 2 * v.toNat + 1 < 2 ^ 63 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ 2 * v.toNat + 1 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | norm_num only at h ⊢ | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | omega | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | decide | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ↑(-9) = -9 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ↑(-9) = -9
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Floating.val_ofUInt8 | [184, 1] | [187, 58] | norm_num | α β : Type
v : UInt8
up : Bool
⊢ 2 ^ 8 < 2 ^ 63 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
up : Bool
⊢ 2 ^ 8 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [quantize] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈ approx x.quantize | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈ approx x.quantize
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hc : x.untrusted_quantize = c | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hl : c.unquantize.sub half_color_error.lo true = lo | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hh : c.unquantize.add half_color_error.lo false = hi | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [hl, hh, ne_eq, Floating.val_le_val] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | by_cases n : lo = nan ∨ hi = nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rcases not_or.mp n with ⟨n0,n1⟩ | case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [n0, not_false_eq_true, n1, true_and] | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have mn : c.unquantize ≠ nan := by rw [←hl] at n0; exact (Floating.ne_nan_of_sub n0).1 | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | by_cases g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rcases n with n | n | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | all_goals simp [n] | case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp [n] | case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [←hl] at n0 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact (Floating.ne_nan_of_sub n0).1 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have xn : x ≠ nan := by
contrapose g
simp only [ne_eq, not_not] at g
simp only [g, lo_nan, hi_nan, Floating.val_nan_le, and_true, not_le, ←Floating.val_lt_val]
exact Floating.nan_lt n0 | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [g, and_self, ↓reduceIte, approx_some, approx, Rat.cast_div, Rat.cast_ofNat, mem_Icc,
tsub_le_iff_right, UInt8.color, add_div] | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [approx, lo_eq_nan, xn, ↓reduceIte, mem_Icc] at xm | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have e : half_color_error.lo.val ≤ color_error / 2 := by
rw [half_color_error]
apply lo_le (by native_decide)
have e : (color_error : ℝ) / 2 = (color_error / 2 : ℚ) := by
simp only [Rat.cast_div, Rat.cast_ofNat]
rw [e]; mono | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [←hl, ←hh] at n0 n1 mn g | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have le_lo := Floating.le_sub n0 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have le_hi := Floating.add_le n1 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [UInt8.val_unquantize mn, hl, tsub_le_iff_right, hh, hl, hh] at le_lo le_hi g ⊢ | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact ⟨by linarith, by linarith⟩ | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | contrapose g | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x ≠ nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [ne_eq, not_not] at g | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [g, lo_nan, hi_nan, Floating.val_nan_le, and_true, not_le, ←Floating.val_lt_val] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact Floating.nan_lt n0 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [half_color_error] | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ half_color_error.lo.val ≤ ↑color_error / 2 | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ (ofRat (color_error / 2)).lo.val ≤ ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ half_color_error.lo.val ≤ ↑color_error / 2
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.