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/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | simp only [eq_empty_iff_forall_not_mem, mem_inter_iff, mem_preimage, mem_singleton_iff, not_and] | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
⊢ (extChartAt I z).target ∩ ↑(extChartAt I z).symm ⁻¹' {a} = ∅ | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
⊢ ∀ x ∈ (extChartAt I z).target, ¬↑(extChartAt I z).symm x = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
⊢ (extChartAt I z).target ∩ ↑(extChartAt I z).symm ⁻¹' {a} = ∅
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | intro x m | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
⊢ ∀ x ∈ (extChartAt I z).target, ¬↑(extChartAt I z).symm x = a | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
x : ℂ
m : x ∈ (extChartAt I z).target
⊢ ¬↑(extChartAt I z).symm x = a | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
⊢ ∀ x ∈ (extChartAt I z).target, ¬↑(extChartAt I z).symm x = a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | contrapose az | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
x : ℂ
m : x ∈ (extChartAt I z).target
⊢ ¬↑(extChartAt I z).symm x = a | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ¬¬↑(extChartAt I z).symm x = a
⊢ ¬a ∉ (extChartAt I z).source | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
az : a ∉ (extChartAt I z).source
x : ℂ
m : x ∈ (extChartAt I z).target
⊢ ¬↑(extChartAt I z).symm x = a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | simp only [not_not] at az ⊢ | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ¬¬↑(extChartAt I z).symm x = a
⊢ ¬a ∉ (extChartAt I z).source | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ a ∈ (extChartAt I z).source | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ¬¬↑(extChartAt I z).symm x = a
⊢ ¬a ∉ (extChartAt I z).source
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | rw [← az] | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ a ∈ (extChartAt I z).source | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ ↑(extChartAt I z).symm x ∈ (extChartAt I z).source | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ a ∈ (extChartAt I z).source
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | AnalyticManifold.nonseparating_singleton | [220, 1] | [230, 38] | exact PartialEquiv.map_target _ m | case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ ↑(extChartAt I z).symm x ∈ (extChartAt I z).source | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
a z : S
x : ℂ
m : x ∈ (extChartAt I z).target
az : ↑(extChartAt I z).symm x = a
⊢ ↑(extChartAt I z).symm x ∈ (extChartAt I z).source
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | apply IsPreconnected.open_diff sc so | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ IsPreconnected (s \ {p | p.2 = a}) | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ Nonseparating {p | p.2 = a} | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ IsPreconnected (s \ {p | p.2 = a})
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | have e : {p : ℂ × S | p.2 = a} = univ ×ˢ {a} := by
apply Set.ext; intro ⟨c, z⟩
simp only [mem_prod_eq, mem_setOf, mem_univ, true_and_iff, mem_singleton_iff] | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ Nonseparating {p | p.2 = a} | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating {p | p.2 = a} | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ Nonseparating {p | p.2 = a}
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | rw [e] | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating {p | p.2 = a} | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating (univ ×ˢ {a}) | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating {p | p.2 = a}
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | exact Nonseparating.univ_prod (AnalyticManifold.nonseparating_singleton _) | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating (univ ×ˢ {a}) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
e : {p | p.2 = a} = univ ×ˢ {a}
⊢ Nonseparating (univ ×ˢ {a})
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | apply Set.ext | X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ {p | p.2 = a} = univ ×ˢ {a} | case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ ∀ (x : ℂ × S), x ∈ {p | p.2 = a} ↔ x ∈ univ ×ˢ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ {p | p.2 = a} = univ ×ˢ {a}
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | intro ⟨c, z⟩ | case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ ∀ (x : ℂ × S), x ∈ {p | p.2 = a} ↔ x ∈ univ ×ˢ {a} | case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
c : ℂ
z : S
⊢ (c, z) ∈ {p | p.2 = a} ↔ (c, z) ∈ univ ×ˢ {a} | Please generate a tactic in lean4 to solve the state.
STATE:
case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
⊢ ∀ (x : ℂ × S), x ∈ {p | p.2 = a} ↔ x ∈ univ ×ˢ {a}
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/AnalyticManifold/Nonseparating.lean | IsPreconnected.open_diff_line | [238, 1] | [244, 85] | simp only [mem_prod_eq, mem_setOf, mem_univ, true_and_iff, mem_singleton_iff] | case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
c : ℂ
z : S
⊢ (c, z) ∈ {p | p.2 = a} ↔ (c, z) ∈ univ ×ˢ {a} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
X : Type
inst✝⁴ : TopologicalSpace X
Y : Type
inst✝³ : TopologicalSpace Y
S : Type
inst✝² : TopologicalSpace S
inst✝¹ : ChartedSpace ℂ S
inst✝ : AnalyticManifold I S
s : Set (ℂ × S)
sc : IsPreconnected s
so : IsOpen s
a : S
c : ℂ
z : S
⊢ (c, z) ∈ {p | p.2 = a} ↔ (c, z) ∈ univ ×ˢ {a}
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | induction x | α β : Type
x y : Color α
⊢ x = y ↔ x.r = y.r ∧ x.g = y.g ∧ x.b = y.b ∧ x.a = y.a | case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x y : Color α
⊢ x = y ↔ x.r = y.r ∧ x.g = y.g ∧ x.b = y.b ∧ x.a = y.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | induction y | case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a | case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
α β : Type
y : Color α
r✝ g✝ b✝ a✝ : α
⊢ { r := r✝, g := g✝, b := b✝, a := a✝ } = y ↔
{ r := r✝, g := g✝, b := b✝, a := a✝ }.r = y.r ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.g = y.g ∧
{ r := r✝, g := g✝, b := b✝, a := a✝ }.b = y.b ∧ { r := r✝, g := g✝, b := b✝, a := a✝ }.a = y.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.ext_iff | [26, 1] | [27, 49] | simp only [mk.injEq] | case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
α β : Type
r✝¹ g✝¹ b✝¹ a✝¹ r✝ g✝ b✝ a✝ : α
⊢ { r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ } = { r := r✝, g := g✝, b := b✝, a := a✝ } ↔
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.r = { r := r✝, g := g✝, b := b✝, a := a✝ }.r ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.g = { r := r✝, g := g✝, b := b✝, a := a✝ }.g ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.b = { r := r✝, g := g✝, b := b✝, a := a✝ }.b ∧
{ r := r✝¹, g := g✝¹, b := b✝¹, a := a✝¹ }.a = { r := r✝, g := g✝, b := b✝, a := a✝ }.a
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | rw [unquantize] at n ⊢ | α β : Type
v : UInt8
n : v.unquantize ≠ nan
⊢ v.unquantize.val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : v.unquantize ≠ nan
⊢ v.unquantize.val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have lt : 2 * v.toNat + 1 < 2^63 := by have h := v.toNat_lt; norm_num only at h ⊢; omega | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have e9 : ((-9 : Int64) : ℤ) = -9 := by decide | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | simp only [Floating.val_scaleB n, Floating.val_ofNat' lt, e9, Nat.cast_add, Nat.cast_mul,
Nat.cast_ofNat, Nat.cast_one, Int.reduceNeg, zpow_neg, add_mul, one_mul, one_div] | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹ | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ ((Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9)).val = ↑v.toNat / 256 + 1 / 512
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | ring_nf | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
e9 : ↑(-9) = -9
⊢ 2 * ↑v.toNat * (2 ^ 9)⁻¹ + (2 ^ 9)⁻¹ = ↑v.toNat / 256 + 512⁻¹
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | have h := v.toNat_lt | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ 2 * v.toNat + 1 < 2 ^ 63 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
⊢ 2 * v.toNat + 1 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | norm_num only at h ⊢ | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63 | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 2 ^ 8
⊢ 2 * v.toNat + 1 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | omega | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
h : v.toNat < 256
⊢ 2 * v.toNat + 1 < 9223372036854775808
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | UInt8.val_unquantize | [164, 1] | [172, 10] | decide | α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ↑(-9) = -9 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
n : (Floating.ofNat (2 * v.toNat + 1) false).scaleB (-9) ≠ nan
lt : 2 * v.toNat + 1 < 2 ^ 63
⊢ ↑(-9) = -9
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Floating.val_ofUInt8 | [184, 1] | [187, 58] | norm_num | α β : Type
v : UInt8
up : Bool
⊢ 2 ^ 8 < 2 ^ 63 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
v : UInt8
up : Bool
⊢ 2 ^ 8 < 2 ^ 63
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [quantize] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈ approx x.quantize | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈ approx x.quantize
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hc : x.untrusted_quantize = c | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
⊢ x' ∈
approx
(let c := x.untrusted_quantize;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hl : c.unquantize.sub half_color_error.lo true = lo | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | generalize hh : c.unquantize.add half_color_error.lo false = hi | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [hl, hh, ne_eq, Floating.val_le_val] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈
approx
(let c := c;
let m := c.unquantize;
let lo := m.sub half_color_error.lo true;
let hi := m.add half_color_error.lo false;
if lo ≠ nan ∧ hi ≠ nan ∧ lo ≤ x.lo ∧ x.hi ≤ hi then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | by_cases n : lo = nan ∨ hi = nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rcases not_or.mp n with ⟨n0,n1⟩ | case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [n0, not_false_eq_true, n1, true_and] | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have mn : c.unquantize ≠ nan := by rw [←hl] at n0; exact (Floating.ne_nan_of_sub n0).1 | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | by_cases g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val | case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rcases n with n | n | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan ∨ hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | all_goals simp [n] | case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.inl
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : lo = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp [n] | case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.inr
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : hi = nan
⊢ x' ∈ approx (if ¬lo = nan ∧ ¬hi = nan ∧ lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [←hl] at n0 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact (Floating.ne_nan_of_sub n0).1 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬hi = nan
⊢ c.unquantize ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have xn : x ≠ nan := by
contrapose g
simp only [ne_eq, not_not] at g
simp only [g, lo_nan, hi_nan, Floating.val_nan_le, and_true, not_le, ←Floating.val_lt_val]
exact Floating.nan_lt n0 | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [g, and_self, ↓reduceIte, approx_some, approx, Rat.cast_div, Rat.cast_ofNat, mem_Icc,
tsub_le_iff_right, UInt8.color, add_div] | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [approx, lo_eq_nan, xn, ↓reduceIte, mem_Icc] at xm | case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have e : half_color_error.lo.val ≤ color_error / 2 := by
rw [half_color_error]
apply lo_le (by native_decide)
have e : (color_error : ℝ) / 2 = (color_error / 2 : ℚ) := by
simp only [Rat.cast_div, Rat.cast_ofNat]
rw [e]; mono | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [←hl, ←hh] at n0 n1 mn g | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have le_lo := Floating.le_sub n0 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have le_hi := Floating.add_le n1 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [UInt8.val_unquantize mn, hl, tsub_le_iff_right, hh, hl, hh] at le_lo le_hi g ⊢ | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
g :
(c.unquantize.sub half_color_error.lo true).val ≤ x.lo.val ∧
x.hi.val ≤ (c.unquantize.add half_color_error.lo false).val
le_lo : c.unquantize.val - half_color_error.lo.val ≤ (c.unquantize.sub half_color_error.lo true).val
le_hi : (c.unquantize.add half_color_error.lo false).val ≤ c.unquantize.val + half_color_error.lo.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact ⟨by linarith, by linarith⟩ | case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 ∧ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | contrapose g | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x ≠ nan | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [ne_eq, not_not] at g | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬x ≠ nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [g, lo_nan, hi_nan, Floating.val_nan_le, and_true, not_le, ←Floating.val_lt_val] | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val) | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | exact Floating.nan_lt n0 | α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : x = nan
⊢ nan < lo
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [half_color_error] | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ half_color_error.lo.val ≤ ↑color_error / 2 | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ (ofRat (color_error / 2)).lo.val ≤ ↑color_error / 2 | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ half_color_error.lo.val ≤ ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | apply lo_le (by native_decide) | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ (ofRat (color_error / 2)).lo.val ≤ ↑color_error / 2 | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2)) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ (ofRat (color_error / 2)).lo.val ≤ ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | have e : (color_error : ℝ) / 2 = (color_error / 2 : ℚ) := by
simp only [Rat.cast_div, Rat.cast_ofNat] | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2)) | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2)) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | rw [e] | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2)) | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑(color_error / 2) ∈ approx (ofRat (color_error / 2)) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑color_error / 2 ∈ approx (ofRat (color_error / 2))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | mono | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑(color_error / 2) ∈ approx (ofRat (color_error / 2)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : ↑color_error / 2 = ↑(color_error / 2)
⊢ ↑(color_error / 2) ∈ approx (ofRat (color_error / 2))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | native_decide | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ofRat (color_error / 2) ≠ nan | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ofRat (color_error / 2) ≠ nan
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [Rat.cast_div, Rat.cast_ofNat] | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑color_error / 2 = ↑(color_error / 2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
⊢ ↑color_error / 2 = ↑(color_error / 2)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | linarith | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ ↑c.toNat / 256 + 1 / 2 / 256 ≤ x' + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | linarith | α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
x' : ℝ
x : Interval
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
mn : c.unquantize ≠ nan
xn : x ≠ nan
xm : x.lo.val ≤ x' ∧ x' ≤ x.hi.val
e : half_color_error.lo.val ≤ ↑color_error / 2
n0 : ¬c.unquantize.sub half_color_error.lo true = nan
n1 : ¬c.unquantize.add half_color_error.lo false = nan
le_lo : ↑c.toNat / 256 + 1 / 512 ≤ lo.val + half_color_error.lo.val
le_hi : hi.val ≤ ↑c.toNat / 256 + 1 / 512 + half_color_error.lo.val
g : lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val
⊢ x' ≤ ↑c.toNat / 256 + 1 / 2 / 256 + ↑color_error / 2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Interval.mem_approx_quantize | [189, 1] | [222, 53] | simp only [g, ↓reduceIte, approx_none, mem_univ] | case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
x' : ℝ
x : Interval
xm : x' ∈ approx x
c : UInt8
hc : x.untrusted_quantize = c
lo : Floating
hl : c.unquantize.sub half_color_error.lo true = lo
hi : Floating
hh : c.unquantize.add half_color_error.lo false = hi
n : ¬(lo = nan ∨ hi = nan)
n0 : ¬lo = nan
n1 : ¬hi = nan
mn : c.unquantize ≠ nan
g : ¬(lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val)
⊢ x' ∈ approx (if lo.val ≤ x.lo.val ∧ x.hi.val ≤ hi.val then some c else none)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | rw [quantize] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
⊢ c' ∈ approx c.quantize | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
⊢ c' ∈
approx
(match (c.r.quantize, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
⊢ c' ∈ approx c.quantize
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | generalize hr : c.r.quantize = r | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
⊢ c' ∈
approx
(match (c.r.quantize, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
⊢ c' ∈
approx
(match (r, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
⊢ c' ∈
approx
(match (c.r.quantize, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | generalize hg : c.g.quantize = g | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
⊢ c' ∈
approx
(match (r, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
⊢ c' ∈
approx
(match (r, g, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
⊢ c' ∈
approx
(match (r, c.g.quantize, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | generalize hb : c.b.quantize = b | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
⊢ c' ∈
approx
(match (r, g, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
⊢ c' ∈
approx
(match (r, g, b, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
⊢ c' ∈
approx
(match (r, g, c.b.quantize, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | generalize ha : c.a.quantize = a | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
⊢ c' ∈
approx
(match (r, g, b, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
⊢ c' ∈
approx
(match (r, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
⊢ c' ∈
approx
(match (r, g, b, c.a.quantize) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | match r with
| none => simp only [approx_nan, mem_univ]
| some r =>
match g with
| none => simp only [approx_nan, mem_univ]
| some g =>
match b with
| none => simp only [approx_nan, mem_univ]
| some b =>
match a with
| none => simp only [approx_nan, mem_univ]
| some a =>
simp only [approx, mem_ite_univ_left]
intro _
simp only [approx] at cm; simp only [approx', mem_setOf_eq] at cm
rcases cm with ⟨m0, m1, m2, m3⟩
simp only [approx', mem_setOf_eq, ←approx_some, ←hr, ←hg, ←hb, ←ha,
Interval.mem_approx_quantize, m0, m1, m2, m3, true_and] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
⊢ c' ∈
approx
(match (r, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r : Option UInt8
hr : c.r.quantize = r
g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
⊢ c' ∈
approx
(match (r, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx_nan, mem_univ] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
hr : c.r.quantize = none
⊢ c' ∈
approx
(match (none, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
hr : c.r.quantize = none
⊢ c' ∈
approx
(match (none, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | match g with
| none => simp only [approx_nan, mem_univ]
| some g =>
match b with
| none => simp only [approx_nan, mem_univ]
| some b =>
match a with
| none => simp only [approx_nan, mem_univ]
| some a =>
simp only [approx, mem_ite_univ_left]
intro _
simp only [approx] at cm; simp only [approx', mem_setOf_eq] at cm
rcases cm with ⟨m0, m1, m2, m3⟩
simp only [approx', mem_setOf_eq, ←approx_some, ←hr, ←hg, ←hb, ←ha,
Interval.mem_approx_quantize, m0, m1, m2, m3, true_and] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
⊢ c' ∈
approx
(match (some r, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g : Option UInt8
hg : c.g.quantize = g
b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
⊢ c' ∈
approx
(match (some r, g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx_nan, mem_univ] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
hg : c.g.quantize = none
⊢ c' ∈
approx
(match (some r, none, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
hg : c.g.quantize = none
⊢ c' ∈
approx
(match (some r, none, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | match b with
| none => simp only [approx_nan, mem_univ]
| some b =>
match a with
| none => simp only [approx_nan, mem_univ]
| some a =>
simp only [approx, mem_ite_univ_left]
intro _
simp only [approx] at cm; simp only [approx', mem_setOf_eq] at cm
rcases cm with ⟨m0, m1, m2, m3⟩
simp only [approx', mem_setOf_eq, ←approx_some, ←hr, ←hg, ←hb, ←ha,
Interval.mem_approx_quantize, m0, m1, m2, m3, true_and] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
⊢ c' ∈
approx
(match (some r, some g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b : Option UInt8
hb : c.b.quantize = b
a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
⊢ c' ∈
approx
(match (some r, some g, b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx_nan, mem_univ] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
hb : c.b.quantize = none
⊢ c' ∈
approx
(match (some r, some g, none, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
hb : c.b.quantize = none
⊢ c' ∈
approx
(match (some r, some g, none, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | match a with
| none => simp only [approx_nan, mem_univ]
| some a =>
simp only [approx, mem_ite_univ_left]
intro _
simp only [approx] at cm; simp only [approx', mem_setOf_eq] at cm
rcases cm with ⟨m0, m1, m2, m3⟩
simp only [approx', mem_setOf_eq, ←approx_some, ←hr, ←hg, ←hb, ←ha,
Interval.mem_approx_quantize, m0, m1, m2, m3, true_and] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
⊢ c' ∈
approx
(match (some r, some g, some b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a : Option UInt8
ha : c.a.quantize = a
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
⊢ c' ∈
approx
(match (some r, some g, some b, a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx_nan, mem_univ] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
ha : c.a.quantize = none
⊢ c' ∈
approx
(match (some r, some g, some b, none) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
ha : c.a.quantize = none
⊢ c' ∈
approx
(match (some r, some g, some b, none) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx, mem_ite_univ_left] | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
⊢ c' ∈
approx
(match (some r, some g, some b, some a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan) | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
⊢ ¬{ r := r, g := g, b := b, a := a } = nan → c' ∈ { r := r, g := g, b := b, a := a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
⊢ c' ∈
approx
(match (some r, some g, some b, some a) with
| (some r, some g, some b, some a) => { r := r, g := g, b := b, a := a }
| x => nan)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | intro _ | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
⊢ ¬{ r := r, g := g, b := b, a := a } = nan → c' ∈ { r := r, g := g, b := b, a := a }.approx' | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
⊢ ¬{ r := r, g := g, b := b, a := a } = nan → c' ∈ { r := r, g := g, b := b, a := a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx] at cm | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ c.approx'
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ approx c
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx', mem_setOf_eq] at cm | α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ c.approx'
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | α β : Type
c' : Color ℝ
c : Color Interval
cm : c'.r ∈ approx c.r ∧ c'.g ∈ approx c.g ∧ c'.b ∈ approx c.b ∧ c'.a ∈ approx c.a
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c' ∈ c.approx'
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | rcases cm with ⟨m0, m1, m2, m3⟩ | α β : Type
c' : Color ℝ
c : Color Interval
cm : c'.r ∈ approx c.r ∧ c'.g ∈ approx c.g ∧ c'.b ∈ approx c.b ∧ c'.a ∈ approx c.a
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | case intro.intro.intro
α β : Type
c' : Color ℝ
c : Color Interval
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
m0 : c'.r ∈ approx c.r
m1 : c'.g ∈ approx c.g
m2 : c'.b ∈ approx c.b
m3 : c'.a ∈ approx c.a
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
c' : Color ℝ
c : Color Interval
cm : c'.r ∈ approx c.r ∧ c'.g ∈ approx c.g ∧ c'.b ∈ approx c.b ∧ c'.a ∈ approx c.a
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_quantize | [230, 1] | [255, 66] | simp only [approx', mem_setOf_eq, ←approx_some, ←hr, ←hg, ←hb, ←ha,
Interval.mem_approx_quantize, m0, m1, m2, m3, true_and] | case intro.intro.intro
α β : Type
c' : Color ℝ
c : Color Interval
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
m0 : c'.r ∈ approx c.r
m1 : c'.g ∈ approx c.g
m2 : c'.b ∈ approx c.b
m3 : c'.a ∈ approx c.a
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α β : Type
c' : Color ℝ
c : Color Interval
r✝ g✝ b✝ a✝¹ : Option UInt8
r : UInt8
hr : c.r.quantize = some r
g : UInt8
hg : c.g.quantize = some g
b : UInt8
hb : c.b.quantize = some b
a : UInt8
ha : c.a.quantize = some a
a✝ : ¬{ r := r, g := g, b := b, a := a } = nan
m0 : c'.r ∈ approx c.r
m1 : c'.g ∈ approx c.g
m2 : c'.b ∈ approx c.b
m3 : c'.a ∈ approx c.a
⊢ c' ∈ { r := r, g := g, b := b, a := a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | mem_approx_lerp | [327, 1] | [333, 24] | rw [lerp, lerp] | α β α' β' : Type
inst✝⁹ : Approx α α'
inst✝⁸ : Approx β β'
inst✝⁷ : Add β
inst✝⁶ : Sub β
inst✝⁵ : AddGroup β'
inst✝⁴ : SMul α β
inst✝³ : SMul α' β'
inst✝² : ApproxAdd β β'
inst✝¹ : ApproxSub β β'
inst✝ : ApproxSMul α β α' β'
t' : α'
x' y' : β'
t : α
x y : β
tm : t' ∈ approx t
xm : x' ∈ approx x
ym : y' ∈ approx y
⊢ lerp t' x' y' ∈ approx (lerp t x y) | α β α' β' : Type
inst✝⁹ : Approx α α'
inst✝⁸ : Approx β β'
inst✝⁷ : Add β
inst✝⁶ : Sub β
inst✝⁵ : AddGroup β'
inst✝⁴ : SMul α β
inst✝³ : SMul α' β'
inst✝² : ApproxAdd β β'
inst✝¹ : ApproxSub β β'
inst✝ : ApproxSMul α β α' β'
t' : α'
x' y' : β'
t : α
x y : β
tm : t' ∈ approx t
xm : x' ∈ approx x
ym : y' ∈ approx y
⊢ x' + t' • (y' - x') ∈ approx (x + t • (y - x)) | Please generate a tactic in lean4 to solve the state.
STATE:
α β α' β' : Type
inst✝⁹ : Approx α α'
inst✝⁸ : Approx β β'
inst✝⁷ : Add β
inst✝⁶ : Sub β
inst✝⁵ : AddGroup β'
inst✝⁴ : SMul α β
inst✝³ : SMul α' β'
inst✝² : ApproxAdd β β'
inst✝¹ : ApproxSub β β'
inst✝ : ApproxSMul α β α' β'
t' : α'
x' y' : β'
t : α
x y : β
tm : t' ∈ approx t
xm : x' ∈ approx x
ym : y' ∈ approx y
⊢ lerp t' x' y' ∈ approx (lerp t x y)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | mem_approx_lerp | [327, 1] | [333, 24] | mono | α β α' β' : Type
inst✝⁹ : Approx α α'
inst✝⁸ : Approx β β'
inst✝⁷ : Add β
inst✝⁶ : Sub β
inst✝⁵ : AddGroup β'
inst✝⁴ : SMul α β
inst✝³ : SMul α' β'
inst✝² : ApproxAdd β β'
inst✝¹ : ApproxSub β β'
inst✝ : ApproxSMul α β α' β'
t' : α'
x' y' : β'
t : α
x y : β
tm : t' ∈ approx t
xm : x' ∈ approx x
ym : y' ∈ approx y
⊢ x' + t' • (y' - x') ∈ approx (x + t • (y - x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α β α' β' : Type
inst✝⁹ : Approx α α'
inst✝⁸ : Approx β β'
inst✝⁷ : Add β
inst✝⁶ : Sub β
inst✝⁵ : AddGroup β'
inst✝⁴ : SMul α β
inst✝³ : SMul α' β'
inst✝² : ApproxAdd β β'
inst✝¹ : ApproxSub β β'
inst✝ : ApproxSMul α β α' β'
t' : α'
x' y' : β'
t : α
x y : β
tm : t' ∈ approx t
xm : x' ∈ approx x
ym : y' ∈ approx y
⊢ x' + t' • (y' - x') ∈ approx (x + t • (y - x))
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_ofRat | [335, 1] | [340, 40] | simp only [coe, approx, ofRat, map] | α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c ∈ approx c.ofRat | α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ { r := ↑c.r, g := ↑c.g, b := ↑c.b, a := ↑c.a } ∈
{ r := Interval.ofRat c.r, g := Interval.ofRat c.g, b := Interval.ofRat c.b, a := Interval.ofRat c.a }.approx' | Please generate a tactic in lean4 to solve the state.
STATE:
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c ∈ approx c.ofRat
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_ofRat | [335, 1] | [340, 40] | simp only [approx', mem_setOf_eq] | α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ { r := ↑c.r, g := ↑c.g, b := ↑c.b, a := ↑c.a } ∈
{ r := Interval.ofRat c.r, g := Interval.ofRat c.g, b := Interval.ofRat c.b, a := Interval.ofRat c.a }.approx' | α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r) ∧
↑c.g ∈ approx (Interval.ofRat c.g) ∧ ↑c.b ∈ approx (Interval.ofRat c.b) ∧ ↑c.a ∈ approx (Interval.ofRat c.a) | Please generate a tactic in lean4 to solve the state.
STATE:
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ { r := ↑c.r, g := ↑c.g, b := ↑c.b, a := ↑c.a } ∈
{ r := Interval.ofRat c.r, g := Interval.ofRat c.g, b := Interval.ofRat c.b, a := Interval.ofRat c.a }.approx'
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_ofRat | [335, 1] | [340, 40] | refine ⟨?_, ?_, ?_, ?_⟩ | α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r) ∧
↑c.g ∈ approx (Interval.ofRat c.g) ∧ ↑c.b ∈ approx (Interval.ofRat c.b) ∧ ↑c.a ∈ approx (Interval.ofRat c.a) | case refine_1
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r)
case refine_2
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.g ∈ approx (Interval.ofRat c.g)
case refine_3
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.b ∈ approx (Interval.ofRat c.b)
case refine_4
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.a ∈ approx (Interval.ofRat c.a) | Please generate a tactic in lean4 to solve the state.
STATE:
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r) ∧
↑c.g ∈ approx (Interval.ofRat c.g) ∧ ↑c.b ∈ approx (Interval.ofRat c.b) ∧ ↑c.a ∈ approx (Interval.ofRat c.a)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_ofRat | [335, 1] | [340, 40] | all_goals apply Interval.approx_ofRat | case refine_1
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r)
case refine_2
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.g ∈ approx (Interval.ofRat c.g)
case refine_3
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.b ∈ approx (Interval.ofRat c.b)
case refine_4
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.a ∈ approx (Interval.ofRat c.a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.r ∈ approx (Interval.ofRat c.r)
case refine_2
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.g ∈ approx (Interval.ofRat c.g)
case refine_3
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.b ∈ approx (Interval.ofRat c.b)
case refine_4
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.a ∈ approx (Interval.ofRat c.a)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Render/Color.lean | Color.mem_approx_ofRat | [335, 1] | [340, 40] | apply Interval.approx_ofRat | case refine_4
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.a ∈ approx (Interval.ofRat c.a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_4
α β α' β' : Type
inst✝¹ : Approx α α'
inst✝ : Approx β β'
c : Color ℚ
⊢ ↑c.a ∈ approx (Interval.ofRat c.a)
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.d0 | [68, 1] | [68, 73] | have h := s.d2 | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ d ≠ 0 | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
h : 2 ≤ d
⊢ d ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ d ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.d0 | [68, 1] | [68, 73] | omega | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
h : 2 ≤ d
⊢ d ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
h : 2 ≤ d
⊢ d ≠ 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.dr2 | [73, 1] | [73, 101] | norm_num | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ 2 ≤ ↑2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ 2 ≤ ↑2
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | g0 | [82, 1] | [82, 92] | simp only [g, eq_self_iff_true, if_true] | f✝ : ℂ → ℂ
d✝ : ℕ
z : ℂ
t : Set ℂ
f : ℂ → ℂ
d : ℕ
⊢ g f d 0 = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f✝ : ℂ → ℂ
d✝ : ℕ
z : ℂ
t : Set ℂ
f : ℂ → ℂ
d : ℕ
⊢ g f d 0 = 1
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.approx | [85, 1] | [88, 10] | have a := s.fa0.leading_approx | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - (z - 0) ^ orderAt f 0 • leadingCoeff f 0) =o[𝓝 0] fun z => (z - 0) ^ orderAt f 0
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.approx | [85, 1] | [88, 10] | simp only [s.fd, s.fc, sub_zero, Pi.one_apply, Algebra.id.smul_eq_mul, mul_one] at a | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - (z - 0) ^ orderAt f 0 • leadingCoeff f 0) =o[𝓝 0] fun z => (z - 0) ^ orderAt f 0
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - (z - 0) ^ orderAt f 0 • leadingCoeff f 0) =o[𝓝 0] fun z => (z - 0) ^ orderAt f 0
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.approx | [85, 1] | [88, 10] | exact a | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
a : (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
⊢ (fun z => f z - z ^ d) =o[𝓝 0] fun z => z ^ d
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.f0 | [91, 1] | [93, 28] | simp [s.fd, s.dp] | f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ orderAt f 0 > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z : ℂ
t : Set ℂ
s : SuperAt f d
⊢ orderAt f 0 > 0
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.fg | [96, 1] | [99, 49] | by_cases z0 : z = 0 | f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
⊢ f z = z ^ d * g f d z | case pos
f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
z0 : z = 0
⊢ f z = z ^ d * g f d z
case neg
f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
z0 : ¬z = 0
⊢ f z = z ^ d * g f d z | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
⊢ f z = z ^ d * g f d z
TACTIC:
|
https://github.com/girving/ray.git | 0be790285dd0fce78913b0cb9bddaffa94bd25f9 | Ray/Dynamics/BottcherNear.lean | SuperAt.fg | [96, 1] | [99, 49] | simp only [z0, zero_pow s.d0, s.f0, MulZeroClass.zero_mul] | case pos
f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
z0 : z = 0
⊢ f z = z ^ d * g f d z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℂ → ℂ
d : ℕ
z✝ : ℂ
t : Set ℂ
s : SuperAt f d
z : ℂ
z0 : z = 0
⊢ f z = z ^ d * g f d z
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.