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/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | rw [←Complex.abs.ne_zero_iff] | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 1 + ↑t * z ≠ 0 | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs (1 + ↑t * z) ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 1 + ↑t * z ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | apply ne_of_gt | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs (1 + ↑t * z) ≠ 0 | case h
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 0 < abs (1 + ↑t * z) | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs (1 + ↑t * z) ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | calc abs (1 + t*z)
_ ≥ Complex.abs 1 - abs (t*z) := Complex.abs.le_add _ _
_ = 1 - |t| * abs z := by simp only [map_one, map_mul, Complex.abs_ofReal]
_ > 0 := by refine sub_pos.mpr (m1 _ (abs_le.mpr ⟨by linarith, t1⟩)) | case h
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 0 < abs (1 + ↑t * z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 0 < abs (1 + ↑t * z)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | continuity | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
⊢ Continuous fun t => 1 + ↑t * z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
⊢ Continuous fun t => 1 + ↑t * z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | simp only [map_one, map_mul, Complex.abs_ofReal] | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs 1 - abs (↑t * z) = 1 - |t| * abs z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs 1 - abs (↑t * z) = 1 - |t| * abs z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | refine sub_pos.mpr (m1 _ (abs_le.mpr ⟨by linarith, t1⟩)) | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 1 - |t| * abs z > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ 1 - |t| * abs z > 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | linarith | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ -1 ≤ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (-(-abs z / (1 - t * abs z))) t
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ -1 ≤ t
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | apply ContinuousOn.intervalIntegrable_of_Icc zero_le_one | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ IntervalIntegrable (fun t => abs z / (1 - t * abs z)) MeasureTheory.volume 0 1 | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ContinuousOn (fun t => abs z / (1 - t * abs z)) (Icc 0 1) | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ IntervalIntegrable (fun t => abs z / (1 - t * abs z)) MeasureTheory.volume 0 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | apply continuousOn_const.div (Continuous.continuousOn (by continuity)) | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ContinuousOn (fun t => abs z / (1 - t * abs z)) (Icc 0 1) | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ∀ x ∈ Icc 0 1, 1 - x * abs z ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ContinuousOn (fun t => abs z / (1 - t * abs z)) (Icc 0 1)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | intro t ⟨_,t1⟩ | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ∀ x ∈ Icc 0 1, 1 - x * abs z ≠ 0 | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
t : ℝ
left✝ : 0 ≤ t
t1 : t ≤ 1
⊢ 1 - t * abs z ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ ∀ x ∈ Icc 0 1, 1 - x * abs z ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | exact ne_of_gt (sub_pos.mpr (m1 _ t1)) | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
t : ℝ
left✝ : 0 ≤ t
t1 : t ≤ 1
⊢ 1 - t * abs z ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
t : ℝ
left✝ : 0 ≤ t
t1 : t ≤ 1
⊢ 1 - t * abs z ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | continuity | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ Continuous fun t => 1 - t * abs z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
dc : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => (1 + ↑t * z).log) (z / (1 + ↑t * z)) t
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
dr : ∀ t ∈ uIcc 0 1, HasDerivAt (fun t => -(1 - t * abs z).log) (abs z / (1 - t * abs z)) t
⊢ Continuous fun t => 1 - t * abs z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Complex.abs_log_one_add_le | [14, 1] | [65, 80] | simp only [map_one, map_mul, Complex.abs_ofReal, _root_.abs_of_nonneg t0] | z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
ir : IntervalIntegrable (fun t => abs z / (1 - t * abs z)) MeasureTheory.volume 0 1
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs 1 - abs (↑t * z) = 1 - t * abs z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
z1 : abs z < 1
m1 : ∀ t ≤ 1, t * abs z < 1
ic : IntervalIntegrable (fun t => z / (1 + ↑t * z)) MeasureTheory.volume 0 1
ir : IntervalIntegrable (fun t => abs z / (1 - t * abs z)) MeasureTheory.volume 0 1
t : ℝ
t0 : 0 ≤ t
t1 : t ≤ 1
⊢ abs 1 - abs (↑t * z) = 1 - t * abs z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | have h := Complex.abs_log_one_add_le (z := x) ?_ | x : ℝ
x1 : |x| < 1
⊢ |(1 + x).log| ≤ -(1 - |x|).log | case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (1 + ↑x).log ≤ -(1 - Complex.abs ↑x).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log
case refine_1
x : ℝ
x1 : |x| < 1
⊢ Complex.abs ↑x < 1 | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x1 : |x| < 1
⊢ |(1 + x).log| ≤ -(1 - |x|).log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | rw [←Complex.ofReal_one, ←Complex.ofReal_add, ←Complex.ofReal_log, Complex.abs_ofReal,
Complex.abs_ofReal] at h | case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (1 + ↑x).log ≤ -(1 - Complex.abs ↑x).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log | case refine_2
x : ℝ
x1 : |x| < 1
h : |(1 + x).log| ≤ -(1 - |x|).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log
case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
⊢ 0 ≤ 1 + x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (1 + ↑x).log ≤ -(1 - Complex.abs ↑x).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | exact h | case refine_2
x : ℝ
x1 : |x| < 1
h : |(1 + x).log| ≤ -(1 - |x|).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
x : ℝ
x1 : |x| < 1
h : |(1 + x).log| ≤ -(1 - |x|).log
⊢ |(1 + x).log| ≤ -(1 - |x|).log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | simp only [abs_lt] at x1 | case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
⊢ 0 ≤ 1 + x | case refine_2
x : ℝ
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
x1 : -1 < x ∧ x < 1
⊢ 0 ≤ 1 + x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
x : ℝ
x1 : |x| < 1
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
⊢ 0 ≤ 1 + x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | linarith | case refine_2
x : ℝ
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
x1 : -1 < x ∧ x < 1
⊢ 0 ≤ 1 + x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
x : ℝ
h : Complex.abs (↑(1 + x)).log ≤ -(1 - Complex.abs ↑x).log
x1 : -1 < x ∧ x < 1
⊢ 0 ≤ 1 + x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.abs_log_one_add_le | [67, 1] | [75, 36] | simpa only [Complex.abs_ofReal] | case refine_1
x : ℝ
x1 : |x| < 1
⊢ Complex.abs ↑x < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
x : ℝ
x1 : |x| < 1
⊢ Complex.abs ↑x < 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.neg_log_one_sub_mono | [77, 1] | [80, 59] | linarith | x y : ℝ
xy : x ≤ y
y1 : y < 1
⊢ 0 < 1 - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℝ
xy : x ≤ y
y1 : y < 1
⊢ 0 < 1 - y
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | Real.neg_log_one_sub_mono | [77, 1] | [80, 59] | linarith | x y : ℝ
xy : x ≤ y
y1 : y < 1
⊢ 1 - y ≤ 1 - x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℝ
xy : x ≤ y
y1 : y < 1
⊢ 1 - y ≤ 1 - x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_two | [82, 1] | [87, 13] | apply le_trans (Real.neg_log_one_sub_mono x2 (by linarith)) ?_ | x : ℝ
x2 : x ≤ 1 / 2
⊢ -(1 - x).log ≤ 2 | x : ℝ
x2 : x ≤ 1 / 2
⊢ -(1 - 1 / 2).log ≤ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x2 : x ≤ 1 / 2
⊢ -(1 - x).log ≤ 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_two | [82, 1] | [87, 13] | rw [neg_le, Real.le_log_iff_exp_le] | x : ℝ
x2 : x ≤ 1 / 2
⊢ -(1 - 1 / 2).log ≤ 2 | x : ℝ
x2 : x ≤ 1 / 2
⊢ (-2).exp ≤ 1 - 1 / 2
x : ℝ
x2 : x ≤ 1 / 2
⊢ 0 < 1 - 1 / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x2 : x ≤ 1 / 2
⊢ -(1 - 1 / 2).log ≤ 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_two | [82, 1] | [87, 13] | linarith | x : ℝ
x2 : x ≤ 1 / 2
⊢ 1 / 2 < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x2 : x ≤ 1 / 2
⊢ 1 / 2 < 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_two | [82, 1] | [87, 13] | exact (exp_neg_ofNat_lt).le | x : ℝ
x2 : x ≤ 1 / 2
⊢ (-2).exp ≤ 1 - 1 / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x2 : x ≤ 1 / 2
⊢ (-2).exp ≤ 1 - 1 / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_two | [82, 1] | [87, 13] | norm_num | x : ℝ
x2 : x ≤ 1 / 2
⊢ 0 < 1 - 1 / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x : ℝ
x2 : x ≤ 1 / 2
⊢ 0 < 1 - 1 / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | rcases le_min_iff.mp xc with ⟨x1,xc⟩ | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
⊢ -(1 - x).log ≤ c * x | case intro
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | by_cases xz : x = 0 | case intro
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
⊢ -(1 - x).log ≤ c * x | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : x = 0
⊢ -(1 - x).log ≤ c * x
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | by_cases xe : x = 1 | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
⊢ -(1 - x).log ≤ c * x | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ -(1 - x).log ≤ c * x
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | replace x1 := Ne.lt_of_le xe x1 | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | have x0' : 0 < x := (Ne.symm xz).lt_of_le x0 | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | have c1p : 0 < (c - 1) * 2 := mul_pos (sub_pos.mpr c1) (by norm_num) | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | have x1p : 0 < 1 - x := by linarith | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | have h := Complex.norm_log_one_add_sub_self_le (z := -x)
(by simp only [norm_neg, Complex.norm_eq_abs, Complex.abs_ofReal, abs_of_nonneg x0]; exact x1) | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : ‖(1 + -↑x).log - -↑x‖ ≤ ‖-↑x‖ ^ 2 * (1 - ‖-↑x‖)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | simp only [Complex.norm_eq_abs, Complex.abs_ofReal, ←Complex.ofReal_one, ←Complex.ofReal_add,
←Complex.ofReal_log x1p.le, ←Complex.ofReal_sub, abs_le, abs_of_nonneg x0, ←Complex.ofReal_neg,
←sub_eq_add_neg, abs_neg] at h | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : ‖(1 + -↑x).log - -↑x‖ ≤ ‖-↑x‖ ^ 2 * (1 - ‖-↑x‖)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(x ^ 2 * (1 - x)⁻¹ / 2) ≤ (1 - x).log - -x ∧ (1 - x).log - -x ≤ x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : ‖(1 + -↑x).log - -↑x‖ ≤ ‖-↑x‖ ^ 2 * (1 - ‖-↑x‖)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | replace h : -Real.log (1 - x) ≤ x + x^2 * (1 - x)⁻¹ / 2 := by linarith | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(x ^ 2 * (1 - x)⁻¹ / 2) ≤ (1 - x).log - -x ∧ (1 - x).log - -x ≤ x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(x ^ 2 * (1 - x)⁻¹ / 2) ≤ (1 - x).log - -x ∧ (1 - x).log - -x ≤ x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | apply le_trans h | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x + x ^ 2 * (1 - x)⁻¹ / 2 ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | rw [pow_two, mul_assoc, mul_div_assoc, ←mul_one_add, mul_comm x _] | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x + x ^ 2 * (1 - x)⁻¹ / 2 ≤ c * x | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (1 + x * (1 - x)⁻¹ / 2) * x ≤ c * x | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x + x ^ 2 * (1 - x)⁻¹ / 2 ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | apply mul_le_mul_of_nonneg_right _ x0 | case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (1 + x * (1 - x)⁻¹ / 2) * x ≤ c * x | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x * (1 - x)⁻¹ / 2 ≤ c | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (1 + x * (1 - x)⁻¹ / 2) * x ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | nth_rw 1 [←inv_inv x] | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x * (1 - x)⁻¹ / 2 ≤ c | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x⁻¹⁻¹ * (1 - x)⁻¹ / 2 ≤ c | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x * (1 - x)⁻¹ / 2 ≤ c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | rw [←mul_inv, mul_sub, mul_one, inv_mul_cancel xz] | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x⁻¹⁻¹ * (1 - x)⁻¹ / 2 ≤ c | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + (x⁻¹ - 1)⁻¹ / 2 ≤ c | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + x⁻¹⁻¹ * (1 - x)⁻¹ / 2 ≤ c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | rw [add_comm, ←le_sub_iff_add_le, div_le_iff (by norm_num)] | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + (x⁻¹ - 1)⁻¹ / 2 ≤ c | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (x⁻¹ - 1)⁻¹ ≤ (c - 1) * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 1 + (x⁻¹ - 1)⁻¹ / 2 ≤ c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | apply inv_le_of_inv_le c1p | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (x⁻¹ - 1)⁻¹ ≤ (c - 1) * 2 | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ ((c - 1) * 2)⁻¹ ≤ x⁻¹ - 1 | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ (x⁻¹ - 1)⁻¹ ≤ (c - 1) * 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | rw [le_sub_iff_add_le, le_inv (add_pos (inv_pos.mpr c1p) (by norm_num)) x0'] | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ ((c - 1) * 2)⁻¹ ≤ x⁻¹ - 1 | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹ | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ ((c - 1) * 2)⁻¹ ≤ x⁻¹ - 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | exact xc | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | simp only [xz, sub_zero, Real.log_one, neg_zero, mul_zero, le_refl] | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : x = 0
⊢ -(1 - x).log ≤ c * x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : x = 0
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | simp only [xe, sub_self, Real.log_zero, neg_zero, mul_one] | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ -(1 - x).log ≤ c * x | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ 0 ≤ c | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ -(1 - x).log ≤ c * x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | linarith | case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ 0 ≤ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
x1 : x ≤ 1
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : x = 1
⊢ 0 ≤ c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | norm_num | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
⊢ 0 < 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
⊢ 0 < 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | linarith | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
⊢ 0 < 1 - x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
⊢ 0 < 1 - x
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | simp only [norm_neg, Complex.norm_eq_abs, Complex.abs_ofReal, abs_of_nonneg x0] | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ ‖-↑x‖ < 1 | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ x < 1 | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ ‖-↑x‖ < 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | exact x1 | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ x < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
⊢ x < 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | linarith | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(x ^ 2 * (1 - x)⁻¹ / 2) ≤ (1 - x).log - -x ∧ (1 - x).log - -x ≤ x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(x ^ 2 * (1 - x)⁻¹ / 2) ≤ (1 - x).log - -x ∧ (1 - x).log - -x ≤ x ^ 2 * (1 - x)⁻¹ / 2
⊢ -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | norm_num | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 0 < 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 0 < 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Log1p.lean | neg_log_one_sub_le_linear | [89, 1] | [116, 11] | norm_num | x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 0 < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x c : ℝ
x0 : 0 ≤ x
c1 : 1 < c
xc✝ : x ≤ min 1 (((c - 1) * 2)⁻¹ + 1)⁻¹
xc : x ≤ (((c - 1) * 2)⁻¹ + 1)⁻¹
xz : ¬x = 0
xe : ¬x = 1
x1 : x < 1
x0' : 0 < x
c1p : 0 < (c - 1) * 2
x1p : 0 < 1 - x
h : -(1 - x).log ≤ x + x ^ 2 * (1 - x)⁻¹ / 2
⊢ 0 < 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | rw [square] | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
⊢ (square lo hi n).dz.1 = (square lo hi n).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
⊢ (let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
⊢ (square lo hi n).dz.1 = (square lo hi n).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | generalize ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2) = c | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
⊢ (let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c : ℚ × ℚ
⊢ (let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
⊢ (let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := ((lo.1 + hi.1) / 2, (lo.2 + hi.2) / 2);
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | generalize hi - lo = d | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c : ℚ × ℚ
⊢ (let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c : ℚ × ℚ
⊢ (let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := hi - lo;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | generalize hdx : max d.1 d.2 / (n : ℚ) = dx | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | generalize hn1 : max 1 (d.1 / dx).ceil.toNat = n1 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | generalize hn2 : max 1 (d.2 / dx).ceil.toNat = n2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | have n1z : (n1 : ℚ) ≠ 0 := by
rw [←hn1]; exact Nat.cast_ne_zero.mpr (ne_of_gt (lt_max_of_lt_left zero_lt_one)) | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | have n2z : (n2 : ℚ) ≠ 0 := by
rw [←hn2]; exact Nat.cast_ne_zero.mpr (ne_of_gt (lt_max_of_lt_left zero_lt_one)) | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
n2z : ↑n2 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | simp only [dz, hdx, hn1, hn2, Prod.smul_mk, smul_eq_mul, Prod.fst_add, Prod.fst_sub, add_sub_sub_cancel,
add_div, mul_div_assoc, div_self n1z, mul_one, add_halves', Prod.snd_add, Prod.snd_sub, div_self n2z] | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
n2z : ↑n2 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
n2z : ↑n2 ≠ 0
⊢ (let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.1 =
(let c := c;
let d := d;
let dx := max d.1 d.2 / ↑n;
let n := (max 1 (d.1 / dx).ceil.toNat, max 1 (d.2 / dx).ceil.toNat);
let h := (dx / 2) • (↑n.1, ↑n.2);
{ lo := c - h, hi := c + h, n := n }).dz.2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | rw [←hn1] | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ ↑n1 ≠ 0 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ ↑(max 1 (d.1 / dx).ceil.toNat) ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ ↑n1 ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | exact Nat.cast_ne_zero.mpr (ne_of_gt (lt_max_of_lt_left zero_lt_one)) | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ ↑(max 1 (d.1 / dx).ceil.toNat) ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
⊢ ↑(max 1 (d.1 / dx).ceil.toNat) ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | rw [←hn2] | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ ↑n2 ≠ 0 | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ ↑(max 1 (d.2 / dx).ceil.toNat) ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ ↑n2 ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Grid.lean | Grid.square_dz | [60, 1] | [75, 106] | exact Nat.cast_ne_zero.mpr (ne_of_gt (lt_max_of_lt_left zero_lt_one)) | E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ ↑(max 1 (d.2 / dx).ceil.toNat) ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
lo hi : ℚ × ℚ
n : ℕ
c d : ℚ × ℚ
dx : ℚ
hdx : max d.1 d.2 / ↑n = dx
n1 : ℕ
hn1 : max 1 (d.1 / dx).ceil.toNat = n1
n2 : ℕ
hn2 : max 1 (d.2 / dx).ceil.toNat = n2
n1z : ↑n1 ≠ 0
⊢ ↑(max 1 (d.2 / dx).ceil.toNat) ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_push_colors | [73, 1] | [81, 10] | induction' n with n h generalizing d o | f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
⊢ (push_colors f n o d).size = d.size + n * 4 | case zero
f : ℕ → Color UInt8
o : ℕ
d : ByteArray
⊢ (push_colors f 0 o d).size = d.size + 0 * 4
case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (push_colors f (n + 1) o d).size = d.size + (n + 1) * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
⊢ (push_colors f n o d).size = d.size + n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_push_colors | [73, 1] | [81, 10] | simp only [Nat.zero_eq, push_colors, ↓reduceIte, zero_mul, add_zero] | case zero
f : ℕ → Color UInt8
o : ℕ
d : ByteArray
⊢ (push_colors f 0 o d).size = d.size + 0 * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
f : ℕ → Color UInt8
o : ℕ
d : ByteArray
⊢ (push_colors f 0 o d).size = d.size + 0 * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_push_colors | [73, 1] | [81, 10] | rw [push_colors] | case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (push_colors f (n + 1) o d).size = d.size + (n + 1) * 4 | case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).size =
d.size + (n + 1) * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (push_colors f (n + 1) o d).size = d.size + (n + 1) * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_push_colors | [73, 1] | [81, 10] | simp only [Nat.succ_eq_add_one, add_eq_zero, one_ne_zero, and_false, ↓reduceIte,
add_tsub_cancel_right, h, ByteArray.size_push] | case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).size =
d.size + (n + 1) * 4 | case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ d.size + 1 + 1 + 1 + 1 + n * 4 = d.size + (n + 1) * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).size =
d.size + (n + 1) * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_push_colors | [73, 1] | [81, 10] | omega | case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ d.size + 1 + 1 + 1 + 1 + n * 4 = d.size + (n + 1) * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
n : ℕ
h : ∀ (o : ℕ) (d : ByteArray), (push_colors f n o d).size = d.size + n * 4
o : ℕ
d : ByteArray
⊢ d.size + 1 + 1 + 1 + 1 + n * 4 = d.size + (n + 1) * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | induction' n with n h generalizing d o | f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : ℕ
lt : k < d.size + n * 4
⊢ (push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size + 0 * 4
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f (n + 1) o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : ℕ
lt : k < d.size + n * 4
⊢ (push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [Nat.zero_eq, zero_mul, add_zero] at lt | case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size + 0 * 4
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size + 0 * 4
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [Nat.zero_eq, push_colors, ↓reduceIte, lt, ↓reduceDite] | case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
f : ℕ → Color UInt8
k o : ℕ
d : ByteArray
lt : k < d.size
⊢ (push_colors f 0 o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | rw [push_colors] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f (n + 1) o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).get!
k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f (n + 1) o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [Nat.succ_ne_zero, ↓reduceIte, Nat.succ_sub_succ_eq_sub, tsub_zero, dite_eq_ite] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).get!
k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (if n + 1 = 0 then d
else
let c := f o;
push_colors f (n + 1 - 1) (o + 1) ((((d.push c.r).push c.g).push c.b).push c.a)).get!
k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [Nat.succ_eq_add_one, add_one_mul, ← add_assoc] at lt | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + (n + 1) * 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | rw [h] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size then
((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).get! k
else
(f
(o + 1 +
(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size) /
4))[↑(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size)]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case succ.lt
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ k < ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size + n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (push_colors f n (o + 1) ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a)).get! k =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [ByteArray.size_push, dite_eq_ite, ByteArray.get!_push, add_assoc] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size then
((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).get! k
else
(f
(o + 1 +
(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size) /
4))[↑(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size)]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + (1 + (1 + (1 + 1))) then
if k < d.size + (1 + (1 + 1)) then
if k < d.size + (1 + 1) then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + (1 + 1) then (f o).b else default
else if k = d.size + (1 + (1 + 1)) then (f o).a else default
else (f (o + (1 + (k - (d.size + (1 + (1 + (1 + 1))))) / 4)))[↑(k - (d.size + (1 + (1 + (1 + 1)))))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size then
((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).get! k
else
(f
(o + 1 +
(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size) /
4))[↑(k - ((((d.push (f o).r).push (f o).g).push (f o).b).push (f o).a).size)]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | norm_num | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + (1 + (1 + (1 + 1))) then
if k < d.size + (1 + (1 + 1)) then
if k < d.size + (1 + 1) then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + (1 + 1) then (f o).b else default
else if k = d.size + (1 + (1 + 1)) then (f o).a else default
else (f (o + (1 + (k - (d.size + (1 + (1 + (1 + 1))))) / 4)))[↑(k - (d.size + (1 + (1 + (1 + 1)))))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + (1 + (1 + (1 + 1))) then
if k < d.size + (1 + (1 + 1)) then
if k < d.size + (1 + 1) then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + (1 + 1) then (f o).b else default
else if k = d.size + (1 + (1 + 1)) then (f o).a else default
else (f (o + (1 + (k - (d.size + (1 + (1 + (1 + 1))))) / 4)))[↑(k - (d.size + (1 + (1 + (1 + 1)))))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | by_cases e0 : k = d.size | case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | by_cases e1 : k = d.size + 1 | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | by_cases e2 : k = d.size + 2 | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | by_cases e3 : k = d.size + 3 | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : ¬k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [← ne_eq] at e0 e1 e2 e3 | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : ¬k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : ¬k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | by_cases lt0 : k < d.size | case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : ¬k < d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp [e0] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k = d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp [e1] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : k = d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp [e2] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : k = d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp [e3] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : ¬k = d.size
e1 : ¬k = d.size + 1
e2 : ¬k = d.size + 2
e3 : k = d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | have lt1 : k < d.size + 1 := by omega | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | have lt2 : k < d.size + 2 := by omega | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | have lt3 : k < d.size + 3 := by omega | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | have lt4 : k < d.size + 4 := by omega | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
lt4 : k < d.size + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | simp only [lt0, lt1, lt2, lt3, lt4, if_true] | case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
lt4 : k < d.size + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
lt3 : k < d.size + 3
lt4 : k < d.size + 4
⊢ (if k < d.size + 4 then
if k < d.size + 3 then
if k < d.size + 2 then
if k < d.size + 1 then if k < d.size then d.get! k else if k = d.size then (f o).r else default
else if k = d.size + 1 then (f o).g else default
else if k = d.size + 2 then (f o).b else default
else if k = d.size + 3 then (f o).a else default
else (f (o + (1 + (k - (d.size + 4)) / 4)))[↑(k - (d.size + 4))]) =
if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | omega | f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
⊢ k < d.size + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
⊢ k < d.size + 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | omega | f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
⊢ k < d.size + 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
⊢ k < d.size + 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | omega | f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
⊢ k < d.size + 3 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
k n : ℕ
h :
∀ (o : ℕ) (d : ByteArray),
k < d.size + n * 4 →
(push_colors f n o d).get! k = if k < d.size then d.get! k else (f (o + (k - d.size) / 4))[↑(k - d.size)]
o : ℕ
d : ByteArray
lt : k < d.size + n * 4 + 4
e0 : k ≠ d.size
e1 : k ≠ d.size + 1
e2 : k ≠ d.size + 2
e3 : k ≠ d.size + 3
lt0 : k < d.size
lt1 : k < d.size + 1
lt2 : k < d.size + 2
⊢ k < d.size + 3
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.