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/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | refine lt_of_lt_of_le (lt_of_le_of_lt (add_le_add iec lcz) ?_) (add_le_add (neg_le_neg iew) lzw) | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ iter_error d c c + (Complex.abs c).log.log < -iter_error d c w + (Complex.abs w).log.log | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 0.15 + (Complex.abs z).log.log < -0.15 + ((Complex.abs z).log.log + 0.548) | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ iter_error d c c + (Complex.abs c).log.log < -iter_error d c w + (Complex.abs w).log.log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | ring_nf | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 0.15 + (Complex.abs z).log.log < -0.15 + ((Complex.abs z).log.log + 0.548) | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 + (Complex.abs z).log.log < 199 / 500 + (Complex.abs z).log.log | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 0.15 + (Complex.abs z).log.log < -0.15 + ((Complex.abs z).log.log + 0.548)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | simp only [add_lt_add_iff_right] | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 + (Complex.abs z).log.log < 199 / 500 + (Complex.abs z).log.log | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 < 199 / 500 | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 + (Complex.abs z).log.log < 199 / 500 + (Complex.abs z).log.log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | norm_num | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 < 199 / 500 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
iew : iter_error d c w ≤ 0.15
⊢ 3 / 20 < 199 / 500
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
⊢ 1 < Complex.abs c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
⊢ 1 < Complex.abs c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | bound | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
⊢ 0 < (↑d)⁻¹ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
⊢ 0 < (↑d)⁻¹
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | rw [f, lift_coe', hw] | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ f d c ↑z = ↑w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ f d c ↑z = ↑w
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | rw [←hw] | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ Complex.abs z ≤ Complex.abs w | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ Complex.abs z ≤ Complex.abs (f' d c z) | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ Complex.abs z ≤ Complex.abs w
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | exact le_self_iter d (by linarith) cz 1 | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ Complex.abs z ≤ Complex.abs (f' d c z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ Complex.abs z ≤ Complex.abs (f' d c z)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ 3 ≤ Complex.abs z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
⊢ 3 ≤ Complex.abs z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
⊢ 2 < Complex.abs c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
⊢ 2 < Complex.abs c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
⊢ 2 < Complex.abs w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
⊢ 2 < Complex.abs w
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
⊢ Complex.abs c ≤ Complex.abs w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
⊢ Complex.abs c ≤ Complex.abs w
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 3 ≤ Complex.abs w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 3 ≤ Complex.abs w
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 3 ≤ Complex.abs c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 3 ≤ Complex.abs c
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | rw [←hw] | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ (Complex.abs z).log.log + 0.548 ≤ (Complex.abs (f' d c z)).log.log | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | exact log_log_iter (by linarith) cz | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ (Complex.abs z).log.log + 0.548 ≤ (Complex.abs (f' d c z)).log.log | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ (Complex.abs z).log.log + 0.548 ≤ (Complex.abs (f' d c z)).log.log
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 4 ≤ Complex.abs z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
⊢ 4 ≤ Complex.abs z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | intro z z4 cz | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
⊢ ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15 | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ iter_error d c z ≤ 0.15 | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
⊢ ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | refine le_trans (iter_error_le_of_z4 d z4 cz) ?_ | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ iter_error d c z ≤ 0.15 | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (Complex.abs z * (Complex.abs z).log) ≤ 0.15 | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ iter_error d c z ≤ 0.15
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | calc 0.8095 / (abs z * log (abs z))
_ ≤ 0.8095 / (4 * log 4) := by bound
_ ≤ 0.8095 / (4 * 1.386) := by bound [lt_log_4]
_ ≤ 0.15 := by norm_num | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (Complex.abs z * (Complex.abs z).log) ≤ 0.15 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (Complex.abs z * (Complex.abs z).log) ≤ 0.15
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | bound | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (Complex.abs z * (Complex.abs z).log) ≤ 0.8095 / (4 * log 4) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (Complex.abs z * (Complex.abs z).log) ≤ 0.8095 / (4 * log 4)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | bound [lt_log_4] | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (4 * log 4) ≤ 0.8095 / (4 * 1.386) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (4 * log 4) ≤ 0.8095 / (4 * 1.386)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | norm_num | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (4 * 1.386) ≤ 0.15 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z✝ : ℂ
c4 : 4 ≤ Complex.abs c
cz✝ : Complex.abs c ≤ Complex.abs z✝
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z✝).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z✝ = w
zw : Complex.abs z✝ ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z✝).log.log + 0.548 ≤ (Complex.abs w).log.log
z : ℂ
z4 : 4 ≤ Complex.abs z
cz : Complex.abs c ≤ Complex.abs z
⊢ 0.8095 / (4 * 1.386) ≤ 0.15
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/Multibrot/Postcritical.lean | postcritical_large | [103, 1] | [142, 54] | linarith | c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
⊢ 4 ≤ Complex.abs w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c✝ : ℂ
d : ℕ
inst✝ : Fact (2 ≤ d)
c z : ℂ
c4 : 4 ≤ Complex.abs c
cz : Complex.abs c ≤ Complex.abs z
d0 : 0 < d
lcz : (Complex.abs c).log.log ≤ (Complex.abs z).log.log
s : Super (f d) d ∞ := superF d
w : ℂ
hw : f' d c z = w
zw : Complex.abs z ≤ Complex.abs w
cw : Complex.abs c ≤ Complex.abs w
pc1 : s.potential c ↑c < 1
pw1 : s.potential c ↑w < 1
lzw : (Complex.abs z).log.log + 0.548 ≤ (Complex.abs w).log.log
ie : ∀ (z : ℂ), 4 ≤ Complex.abs z → Complex.abs c ≤ Complex.abs z → iter_error d c z ≤ 0.15
iec : iter_error d c c ≤ 0.15
⊢ 4 ≤ Complex.abs w
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:
|
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
lt3 : k < d.size + 3
⊢ k < d.size + 4 | 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
lt3 : k < d.size + 3
⊢ k < d.size + 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | have ge : d.size + 4 ≤ k := by omega | 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)] | 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
ge : d.size + 4 ≤ k
⊢ (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
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 e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4 := by omega | 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
ge : d.size + 4 ≤ k
⊢ (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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (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 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
ge : d.size + 4 ≤ k
⊢ (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 e1 : k - d.size = k - (d.size + 4) + 4 := by omega | 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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (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)] | 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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
e1 : k - d.size = k - (d.size + 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 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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (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] | simp only [not_lt.mpr ge, ↓reduceIte, Nat.succ_eq_add_one, e0, e1, lt0, Nat.cast_add,
Fin.natCast_self, add_zero] | 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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
e1 : k - d.size = k - (d.size + 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)] | no goals | 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
lt0 : ¬k < d.size
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
e1 : k - d.size = k - (d.size + 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] | 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
⊢ d.size + 4 ≤ k | 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
⊢ d.size + 4 ≤ k
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
ge : d.size + 4 ≤ k
⊢ o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4 | 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
ge : d.size + 4 ≤ k
⊢ o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
⊢ k - d.size = k - (d.size + 4) + 4 | 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
ge : d.size + 4 ≤ k
e0 : o + (1 + (k - (d.size + 4)) / 4) = o + (k - d.size) / 4
⊢ k - d.size = k - (d.size + 4) + 4
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] | 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 | 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.size + 1 + 1 + 1 + 1 + n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
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
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_push_colors | [83, 1] | [115, 12] | omega | 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.size + 1 + 1 + 1 + 1 + n * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
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.size + 1 + 1 + 1 + 1 + n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get_push_colors | [117, 1] | [123, 71] | simp only [getElem_fin, ByteArray.getElemNat_eq_get!, dite_eq_ite] | f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ (push_colors f n o d)[k] = if h : ↑k < d.size then d[k] else (f (o + (↑k - d.size) / 4))[↑(↑k - d.size)] | f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ (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)] | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ (push_colors f n o d)[k] = if h : ↑k < d.size then d[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 | [117, 1] | [123, 71] | apply get!_push_colors | f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ (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 lt
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ ↑k < d.size + n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ (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 | [117, 1] | [123, 71] | convert k.prop | case lt
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ ↑k < d.size + n * 4 | case h.e'_4
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ d.size + n * 4 = (push_colors f n o d).size | Please generate a tactic in lean4 to solve the state.
STATE:
case lt
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ ↑k < d.size + n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get_push_colors | [117, 1] | [123, 71] | simp only [size_push_colors] | case h.e'_4
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ d.size + n * 4 = (push_colors f n o d).size | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_4
f : ℕ → Color UInt8
n o : ℕ
d : ByteArray
k : Fin (push_colors f n o d).size
⊢ d.size + n * 4 = (push_colors f n o d).size
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.n0_lt_n | [130, 1] | [131, 37] | simp only [le_max_iff] at h | n chunk : ℕ
h : ¬n ≤ max 1 chunk
⊢ n / 2 < n | n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n / 2 < n | Please generate a tactic in lean4 to solve the state.
STATE:
n chunk : ℕ
h : ¬n ≤ max 1 chunk
⊢ n / 2 < n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.n0_lt_n | [130, 1] | [131, 37] | omega | n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n / 2 < n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n / 2 < n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.n1_lt_n | [132, 1] | [133, 37] | simp only [le_max_iff] at h | n chunk : ℕ
h : ¬n ≤ max 1 chunk
⊢ n - n / 2 < n | n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n - n / 2 < n | Please generate a tactic in lean4 to solve the state.
STATE:
n chunk : ℕ
h : ¬n ≤ max 1 chunk
⊢ n - n / 2 < n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.n1_lt_n | [132, 1] | [133, 37] | omega | n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n - n / 2 < n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n chunk : ℕ
h : ¬(n ≤ 1 ∨ n ≤ chunk)
⊢ n - n / 2 < n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | induction' n using Nat.strong_induction_on with n i generalizing o | f : ℕ → Color UInt8
n o chunk : ℕ
⊢ (parallel_colors' f n o chunk).size = n * 4 | case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (parallel_colors' f n o chunk).size = n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o chunk : ℕ
⊢ (parallel_colors' f n o chunk).size = n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | rw [parallel_colors'] | case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (parallel_colors' f n o chunk).size = n * 4 | case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (parallel_colors' f n o chunk).size = n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | by_cases h : n ≤ max 1 chunk | case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4 | case pos
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4
case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | simp only [h, if_true, size_push_colors, ByteArray.size_mkEmpty, zero_add] | case pos
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | simp only [h, if_false, Task.spawn, ByteArray.size_append, i _ (n0_lt_n h), i _ (n1_lt_n h)] | case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4 | case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ n / 2 * 4 + (n - n / 2) * 4 = n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).size =
n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.size_parallel_colors' | [152, 1] | [160, 10] | omega | case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ n / 2 * 4 + (n - n / 2) * 4 = n * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk n : ℕ
i : ∀ m < n, ∀ (o : ℕ), (parallel_colors' f m o chunk).size = m * 4
o : ℕ
h : ¬n ≤ max 1 chunk
⊢ n / 2 * 4 + (n - n / 2) * 4 = n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | have four : ((4 : ℕ) : Fin 4) = 0 := by decide | f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k] | f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
four : ↑4 = 0
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | induction' n using Nat.strong_induction_on with n i generalizing o k | f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
four : ↑4 = 0
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k] | case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
four : ↑4 = 0
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | rw [parallel_colors'] | case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k] | case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (parallel_colors' f n o chunk).get! k = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | by_cases h : n ≤ max 1 chunk | case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k]
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case h
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | decide | f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
⊢ ↑4 = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
n o chunk k : ℕ
lt : k < n * 4
⊢ ↑4 = 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [h, if_true, Task.spawn] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (push_colors f n o (ByteArray.mkEmpty n)).get! k = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | rw [get!_push_colors] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (push_colors f n o (ByteArray.mkEmpty n)).get! k = (f (o + k / 4))[↑k] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if k < (ByteArray.mkEmpty n).size then (ByteArray.mkEmpty n).get! k
else (f (o + (k - (ByteArray.mkEmpty n).size) / 4))[↑(k - (ByteArray.mkEmpty n).size)]) =
(f (o + k / 4))[↑k]
case pos.lt
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ k < (ByteArray.mkEmpty n).size + n * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (push_colors f n o (ByteArray.mkEmpty n)).get! k = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [ByteArray.size_mkEmpty, not_lt_zero', ↓reduceIte, tsub_zero] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if k < (ByteArray.mkEmpty n).size then (ByteArray.mkEmpty n).get! k
else (f (o + (k - (ByteArray.mkEmpty n).size) / 4))[↑(k - (ByteArray.mkEmpty n).size)]) =
(f (o + k / 4))[↑k] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ (if k < (ByteArray.mkEmpty n).size then (ByteArray.mkEmpty n).get! k
else (f (o + (k - (ByteArray.mkEmpty n).size) / 4))[↑(k - (ByteArray.mkEmpty n).size)]) =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simpa only [ByteArray.size_mkEmpty, zero_add] | case pos.lt
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ k < (ByteArray.mkEmpty n).size + n * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.lt
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : n ≤ max 1 chunk
⊢ k < (ByteArray.mkEmpty n).size + n * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [h, if_false, Task.spawn, ByteArray.get!_append, size_parallel_colors'] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if n ≤ max 1 chunk then push_colors f n o (ByteArray.mkEmpty n)
else
let n0 := n / 2;
let t0 := Task.spawn fun x => parallel_colors' f n0 o chunk;
let t1 := Task.spawn fun x => parallel_colors' f (n - n0) (o + n0) chunk;
t0.get ++ t1.get).get!
k =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [le_max_iff, not_or, not_le] at h | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : ¬n ≤ max 1 chunk
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | by_cases c : k < n/2 * 4 | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k]
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [c, ↓reduceIte] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (parallel_colors' f (n / 2) o chunk).get! k = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | rw [i _ (by omega) _ _ (by omega)] | case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (parallel_colors' f (n / 2) o chunk).get! k = (f (o + k / 4))[↑k] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ (parallel_colors' f (n / 2) o chunk).get! k = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | omega | f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ n / 2 < n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ n / 2 < n
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | omega | f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ k < n / 2 * 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : k < n / 2 * 4
⊢ k < n / 2 * 4
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | simp only [c, ↓reduceIte] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4) = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (if k < n / 2 * 4 then (parallel_colors' f (n / 2) o chunk).get! k
else (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4)) =
(f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | rw [i] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4) = (f (o + k / 4))[↑k] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (f (o + n / 2 + (k - n / 2 * 4) / 4))[↑(k - n / 2 * 4)] = (f (o + k / 4))[↑k]
case neg.a
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ n - n / 2 < n
case neg.lt
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ k - n / 2 * 4 < (n - n / 2) * 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (parallel_colors' f (n - n / 2) (o + n / 2) chunk).get! (k - n / 2 * 4) = (f (o + k / 4))[↑k]
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Image.lean | Image.get!_parallel_colors' | [162, 1] | [183, 14] | have ke : o + n / 2 + (k - n / 2 * 4) / 4 = o + k / 4 := by omega | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (f (o + n / 2 + (k - n / 2 * 4) / 4))[↑(k - n / 2 * 4)] = (f (o + k / 4))[↑k] | case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
ke : o + n / 2 + (k - n / 2 * 4) / 4 = o + k / 4
⊢ (f (o + n / 2 + (k - n / 2 * 4) / 4))[↑(k - n / 2 * 4)] = (f (o + k / 4))[↑k] | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → Color UInt8
chunk : ℕ
four : ↑4 = 0
n : ℕ
i : ∀ m < n, ∀ (o k : ℕ), k < m * 4 → (parallel_colors' f m o chunk).get! k = (f (o + k / 4))[↑k]
o k : ℕ
lt : k < n * 4
h : 1 < n ∧ chunk < n
c : ¬k < n / 2 * 4
⊢ (f (o + n / 2 + (k - n / 2 * 4) / 4))[↑(k - n / 2 * 4)] = (f (o + k / 4))[↑k]
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.