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/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | ring | case h.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
h3g0 : 0 ≤ 3
hSphere₂ : (rx * rx + ry * ry + rz * rz) * 4 / 3 = 1
⊢ rx ^ 2 * 3⁻¹ * 4 + 3⁻¹ * ry ^ 2 * 4 + 3⁻¹ * rz ^ 2 * 4 = (rx * rx + ry * ry + rz * rz) * 4 / 3 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
h3g0 : 0 ≤ 3
hSphere₂ : (rx * rx + ry * ry + rz * rz) * 4 / 3 = 1
⊢ rx ^ 2 * 3⁻¹ * 4 + 3⁻¹ * ry ^ 2 * 4 + 3⁻¹ * rz ^ 2 * 4 = (rx * rx + ry * ry + rz * rz) * 4 / 3
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | linarith | r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ 0 ≤ 3 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ 0 ≤ 3
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | constructor | case h.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ r = 2⁻¹.re + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).re ∧
x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI ∧
y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | case h.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ r = 2⁻¹.re + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).re
case h.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI ∧
y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ r = 2⁻¹.re + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).re ∧
x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI ∧
y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ r = 2⁻¹.re + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).re | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ r = 2⁻¹.re + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).re
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | constructor | case h.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI ∧
y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | case h.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI
case h.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI ∧
y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ x = 2⁻¹.imI + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imI
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | constructor | case h.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | case h.right.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ
case h.right.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ ∧
z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.right.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.right.right.left
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ y = 2⁻¹.imJ + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imJ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.right.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.right.right.right
r x y z rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 3 / 4
hr : r = 2⁻¹
hx : x = rx
hy : y = ry
hz : z = rz
⊢ z = 2⁻¹.imK + ({ re := 0, imI := rx * 2 / √3, imJ := ry * 2 / √3, imK := rz * 2 / √3 } * ↑√3 / 2).imK
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | intros h₀ | case h.mk.mpr
r x y z : ℝ
⊢ (∃ qim,
(∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1) ∧
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK) →
∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk.mpr
r x y z : ℝ
h₀ :
∃ qim,
(∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1) ∧
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : ℝ
⊢ (∃ qim,
(∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1) ∧
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK) →
∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | rcases h₀ with ⟨qim, hx₁, hx₂⟩ | case h.mk.mpr
r x y z : ℝ
h₀ :
∃ qim,
(∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1) ∧
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk.mpr.intro.intro
r x y z : ℝ
qim : ℍ
hx₁ : ∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : ℝ
h₀ :
∃ qim,
(∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1) ∧
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | rcases hx₁ with ⟨rx, ry, rz, hQim, hSphere⟩ | case h.mk.mpr.intro.intro
r x y z : ℝ
qim : ℍ
hx₁ : ∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk.mpr.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro
r x y z : ℝ
qim : ℍ
hx₁ : ∃ rx ry rz, (qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz) ∧ rx * rx + ry * ry + rz * rz = 1
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | rcases hx₂ with ⟨hr, hx, hy, hz⟩ | case h.mk.mpr.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
hx₂ :
r = 2⁻¹.re + (qim * ↑√3 / 2).re ∧
x = 2⁻¹.imI + (qim * ↑√3 / 2).imI ∧ y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ ∧ z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | rcases hQim with ⟨hQimR, hQimI, hQimJ, hQimK⟩ | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hQim : qim.re = 0 ∧ qim.imI = rx ∧ qim.imJ = ry ∧ qim.imK = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | use x | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4 | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ ry rz, (r = 2⁻¹ ∧ x = x ∧ y = ry ∧ z = rz) ∧ x * x + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rx ry rz, (r = 2⁻¹ ∧ x = rx ∧ y = ry ∧ z = rz) ∧ rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | use y | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ ry rz, (r = 2⁻¹ ∧ x = x ∧ y = ry ∧ z = rz) ∧ x * x + ry * ry + rz * rz = 3 / 4 | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rz, (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = rz) ∧ x * x + y * y + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ ry rz, (r = 2⁻¹ ∧ x = x ∧ y = ry ∧ z = rz) ∧ x * x + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | use z | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rz, (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = rz) ∧ x * x + y * y + rz * rz = 3 / 4 | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = z) ∧ x * x + y * y + z * z = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ ∃ rz, (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = rz) ∧ x * x + y * y + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | simp only [and_self, and_true] | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = z) ∧ x * x + y * y + z * z = 3 / 4 | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹ ∧ x * x + y * y + z * z = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ (r = 2⁻¹ ∧ x = x ∧ y = y ∧ z = z) ∧ x * x + y * y + z * z = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | constructor | case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹ ∧ x * x + y * y + z * z = 3 / 4 | case h.left
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹
case h.right
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ x * x + y * y + z * z = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹ ∧ x * x + y * y + z * z = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.left
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ r = 2⁻¹
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1₁AndSoqqtstqm1₃ | [192, 1] | [234, 12] | sorry | case h.right
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ x * x + y * y + z * z = 3 / 4 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
r x y z : ℝ
qim : ℍ
rx ry rz : ℝ
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 2⁻¹.re + (qim * ↑√3 / 2).re
hx : x = 2⁻¹.imI + (qim * ↑√3 / 2).imI
hy : y = 2⁻¹.imJ + (qim * ↑√3 / 2).imJ
hz : z = 2⁻¹.imK + (qim * ↑√3 / 2).imK
hQimR : qim.re = 0
hQimI : qim.imI = rx
hQimJ : qim.imJ = ry
hQimK : qim.imK = rz
⊢ x * x + y * y + z * z = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesOr | [5, 1] | [6, 8] | tauto | p q r : Prop
⊢ p → q ∨ r ↔ (p → q) ∨ (p → r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → q ∨ r ↔ (p → q) ∨ (p → r)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesAnd | [8, 1] | [9, 8] | tauto | p q r : Prop
⊢ p → q ∧ r ↔ (p → q) ∧ (p → r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → q ∧ r ↔ (p → q) ∧ (p → r)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesImplies | [11, 1] | [12, 8] | tauto | p q r : Prop
⊢ p → q → r ↔ (p → q) → p → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → q → r ↔ (p → q) → p → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesIff | [14, 1] | [15, 8] | tauto | p q r : Prop
⊢ p → (q ↔ r) ↔ (p → q ↔ p → r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → (q ↔ r) ↔ (p → q ↔ p → r)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | trueImpliesOnlyTrue | [17, 1] | [18, 8] | tauto | p r : Prop
⊢ p → (p → r ↔ r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p r : Prop
⊢ p → (p → r ↔ r)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesReorder | [20, 1] | [21, 8] | tauto | p q r : Prop
⊢ p → q → r ↔ q → p → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → q → r ↔ q → p → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesAndImplies | [23, 1] | [24, 8] | tauto | p q r : Prop
⊢ p → q → r ↔ q ∧ p → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q r : Prop
⊢ p → q → r ↔ q ∧ p → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesOrImplies | [26, 1] | [27, 8] | tauto | p₀ p₁ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ↔ p₀ ∨ p₁ → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p₀ p₁ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ↔ p₀ ∨ p₁ → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesOrImplies3 | [29, 1] | [30, 8] | tauto | p₀ p₁ p₂ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ∧ (p₂ → r) ↔ p₀ ∨ p₁ ∨ p₂ → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p₀ p₁ p₂ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ∧ (p₂ → r) ↔ p₀ ∨ p₁ ∨ p₂ → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesOrImplies4 | [32, 1] | [33, 8] | tauto | p₀ p₁ p₂ p₃ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ∧ (p₂ → r) ∧ (p₃ → r) ↔ p₀ ∨ p₁ ∨ p₂ ∨ p₃ → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p₀ p₁ p₂ p₃ r : Prop
⊢ (p₀ → r) ∧ (p₁ → r) ∧ (p₂ → r) ∧ (p₃ → r) ↔ p₀ ∨ p₁ ∨ p₂ ∨ p₃ → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | impliesOrImpliesGeneralized | [35, 1] | [36, 8] | aesop | k : ℕ+
p : ℕ → Prop
r : Prop
⊢ (∀ k₀ ∈ range ↑k, p k₀ → r) ↔ (∃ k₀ ∈ range ↑k, p k₀) → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ+
p : ℕ → Prop
r : Prop
⊢ (∀ k₀ ∈ range ↑k, p k₀ → r) ↔ (∃ k₀ ∈ range ↑k, p k₀) → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | combineCases | [38, 1] | [39, 8] | tauto | q r : Prop
⊢ (q → r) ∧ (¬q → r) ↔ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
q r : Prop
⊢ (q → r) ∧ (¬q → r) ↔ r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | combineCasesGeneralized | [41, 1] | [42, 8] | tauto | k : ℕ+
p : ℕ → Prop
r : Prop
⊢ (∃ k₀ ∈ range ↑k, p k₀) → (r ↔ ∀ k₀ ∈ range ↑k, p k₀ → r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ+
p : ℕ → Prop
r : Prop
⊢ (∃ k₀ ∈ range ↑k, p k₀) → (r ↔ ∀ k₀ ∈ range ↑k, p k₀ → r)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | squashImplies | [44, 1] | [45, 8] | tauto | q r : Prop
⊢ q → q → r ↔ q → r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
q r : Prop
⊢ q → q → r ↔ q → r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/Prop.lean | insightFromGeneralization | [47, 1] | [48, 8] | tauto | p₀ p₁ p₂ : Prop
⊢ (p₀ ↔ p₁ → p₂) → p₁ → (p₀ ↔ p₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p₀ p₁ p₂ : Prop
⊢ (p₀ ↔ p₁ → p₂) → p₁ → (p₀ ↔ p₂)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | ExpTsumForm | [7, 1] | [8, 37] | rw [exp_eq_exp_ℂ, exp_eq_tsum_div] | z : ℂ
⊢ cexp z = ∑' (k : ℕ), z ^ k / ↑k.factorial | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
⊢ cexp z = ∑' (k : ℕ), z ^ k / ↑k.factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | ExpTaylorSeriesSummable | [10, 1] | [11, 35] | exact expSeries_div_summable ℂ z | z : ℂ
⊢ Summable fun k => z ^ k / ↑k.factorial | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
z : ℂ
⊢ Summable fun k => z ^ k / ↑k.factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | rw [Rues] | n : ℕ+
x : ℝ
⊢ (Rues n ↑x).im = 0 | n : ℕ+
x : ℝ
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
⊢ (Rues n ↑x).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | let h₀ := ContinuousLinearMap.map_tsum Complex.imCLM (RuesSummable n x) | n : ℕ+
x : ℝ
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : imCLM (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial) =
∑' (z : ℕ), imCLM (↑x ^ (↑n * z) / ↑(↑n * z).factorial) :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | simp only [imCLM_apply] at h₀ | n : ℕ+
x : ℝ
h₀ : imCLM (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial) =
∑' (z : ℕ), imCLM (↑x ^ (↑n * z) / ↑(↑n * z).factorial) :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : imCLM (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial) =
∑' (z : ℕ), imCLM (↑x ^ (↑n * z) / ↑(↑n * z).factorial) :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | rw [h₀] | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (∑' (k : ℕ), ↑x ^ (↑n * k) / ↑(↑n * k).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | suffices h₁ : ∑' (z : ℕ), (x ^ (n * z) : ℂ).im / ↑(Nat.factorial (n * z)) = ∑' (z : ℕ), 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0
case h₁
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | congr | case h₁
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0 | case h₁.e_f
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (fun z => (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial) = fun z => 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h₁
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | ext1 k | case h₁.e_f
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (fun z => (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial) = fun z => 0 | case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ (↑x ^ (↑n * k)).im / ↑(↑n * k).factorial = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h₁.e_f
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
⊢ (fun z => (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial) = fun z => 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | norm_cast at * | case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ (↑x ^ (↑n * k)).im / ↑(↑n * k).factorial = 0 | case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ 0 / ↑(↑n * k).factorial = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ (↑x ^ (↑n * k)).im / ↑(↑n * k).factorial = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | simp only [zero_div] | case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ 0 / ↑(↑n * k).factorial = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h₁.e_f.h
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
k : ℕ
⊢ 0 / ↑(↑n * k).factorial = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | rw [tsum_zero] at h₁ | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = ∑' (z : ℕ), 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | rw [←h₁] | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0 | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRealToReal | [22, 1] | [34, 23] | simp only [div_natCast_im] | n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
x : ℝ
h₀ : (∑' (z : ℕ), ↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im :=
ContinuousLinearMap.map_tsum imCLM (RuesSummable n ↑x)
h₁ : ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial = 0
⊢ ∑' (z : ℕ), (↑x ^ (↑n * z) / ↑(↑n * z).factorial).im = ∑' (z : ℕ), (↑x ^ (↑n * z)).im / ↑(↑n * z).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | simp_rw [Rues] | n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ Rues n z = Rues n (z * rou) | n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ ∑' (k : ℕ), z ^ (↑n * k) / ↑(↑n * k).factorial = ∑' (k : ℕ), (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ Rues n z = Rues n (z * rou)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | congr | n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ ∑' (k : ℕ), z ^ (↑n * k) / ↑(↑n * k).factorial = ∑' (k : ℕ), (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | case e_f
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ (fun k => z ^ (↑n * k) / ↑(↑n * k).factorial) = fun k => (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ ∑' (k : ℕ), z ^ (↑n * k) / ↑(↑n * k).factorial = ∑' (k : ℕ), (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | ext1 k | case e_f
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ (fun k => z ^ (↑n * k) / ↑(↑n * k).factorial) = fun k => (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
⊢ (fun k => z ^ (↑n * k) / ↑(↑n * k).factorial) = fun k => (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | have h₀ : (z * rou) ^ (n * k) = z ^ (n * k) * rou ^ (n * k) := by
exact mul_pow z rou (↑n * k) | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | have h₁ : rou ^ (n * k) = (rou ^ (n : ℕ)) ^ k := by
exact pow_mul rou (↑n) k | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
h₁ : rou ^ (↑n * k) = (rou ^ ↑n) ^ k
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | simp only [h₀, h₁, h, one_pow, mul_one] | case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
h₁ : rou ^ (↑n * k) = (rou ^ ↑n) ^ k
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
h₁ : rou ^ (↑n * k) = (rou ^ ↑n) ^ k
⊢ z ^ (↑n * k) / ↑(↑n * k).factorial = (z * rou) ^ (↑n * k) / ↑(↑n * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | exact mul_pow z rou (↑n * k) | n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
⊢ (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
⊢ (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesRotationallySymmetric | [36, 1] | [44, 42] | exact pow_mul rou (↑n) k | n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
⊢ rou ^ (↑n * k) = (rou ^ ↑n) ^ k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
z rou : ℂ
h : rou ^ ↑n = 1
k : ℕ
h₀ : (z * rou) ^ (↑n * k) = z ^ (↑n * k) * rou ^ (↑n * k)
⊢ rou ^ (↑n * k) = (rou ^ ↑n) ^ k
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RouNot0 | [46, 1] | [49, 81] | by_contra h₁ | n : ℕ+
rou : ℂ
h : rou ^ ↑n = 1
⊢ rou ≠ 0 | n : ℕ+
rou : ℂ
h : rou ^ ↑n = 1
h₁ : rou = 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
rou : ℂ
h : rou ^ ↑n = 1
⊢ rou ≠ 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RouNot0 | [46, 1] | [49, 81] | rw [h₁] at h | n : ℕ+
rou : ℂ
h : rou ^ ↑n = 1
h₁ : rou = 0
⊢ False | n : ℕ+
rou : ℂ
h : 0 ^ ↑n = 1
h₁ : rou = 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
rou : ℂ
h : rou ^ ↑n = 1
h₁ : rou = 0
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RouNot0 | [46, 1] | [49, 81] | simp only [ne_eq, PNat.ne_zero, not_false_eq_true, zero_pow, zero_ne_one] at h | n : ℕ+
rou : ℂ
h : 0 ^ ↑n = 1
h₁ : rou = 0
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
rou : ℂ
h : 0 ^ ↑n = 1
h₁ : rou = 0
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSummable | [56, 1] | [57, 8] | sorry | n : ℕ+
m : ℤ
z : ℂ
⊢ Summable fun k => if ↑↑n ∣ ↑k + m then z ^ k / ↑k.factorial else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
m : ℤ
z : ℂ
⊢ Summable fun k => if ↑↑n ∣ ↑k + m then z ^ k / ↑k.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffHasDeriv | [59, 1] | [60, 8] | sorry | n : ℕ+
m : ℤ
z : ℂ
⊢ HasDerivAt (RuesDiff n m) (RuesDiff n (m + 1) z) z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
m : ℤ
z : ℂ
⊢ HasDerivAt (RuesDiff n m) (RuesDiff n (m + 1) z) z
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffDeriv | [62, 1] | [63, 8] | sorry | n : ℕ+
m : ℤ
⊢ deriv (RuesDiff n m) = RuesDiff n (m + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
m : ℤ
⊢ deriv (RuesDiff n m) = RuesDiff n (m + 1)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | induction' k with K Kih | k : ℕ
n : ℕ+
m : ℤ
⊢ iteratedDeriv k (RuesDiff n m) = RuesDiff n (↑k + m) | case zero
n : ℕ+
m : ℤ
⊢ iteratedDeriv 0 (RuesDiff n m) = RuesDiff n (↑0 + m)
case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m) | Please generate a tactic in lean4 to solve the state.
STATE:
k : ℕ
n : ℕ+
m : ℤ
⊢ iteratedDeriv k (RuesDiff n m) = RuesDiff n (↑k + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | simp only [Nat.zero_eq, iteratedDeriv_zero, CharP.cast_eq_zero, zero_add] | case zero
n : ℕ+
m : ℤ
⊢ iteratedDeriv 0 (RuesDiff n m) = RuesDiff n (↑0 + m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
n : ℕ+
m : ℤ
⊢ iteratedDeriv 0 (RuesDiff n m) = RuesDiff n (↑0 + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | have h₀ := congrArg deriv Kih | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m) | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | rw [iteratedDeriv_succ, h₀, RuesDiffDeriv] | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m) | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ iteratedDeriv (K + 1) (RuesDiff n m) = RuesDiff n (↑(K + 1) + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | have h₁ : ↑K + m + 1 = ↑(Nat.succ K) + m := by
simp only [Nat.cast_succ]
ring | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m) | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
h₁ : ↑K + m + 1 = ↑K.succ + m
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m) | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | rw [h₁] | case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
h₁ : ↑K + m + 1 = ↑K.succ + m
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
h₁ : ↑K + m + 1 = ↑K.succ + m
⊢ RuesDiff n (↑K + m + 1) = RuesDiff n (↑(K + 1) + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | simp only [Nat.cast_succ] | n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ ↑K + m + 1 = ↑K.succ + m | n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ ↑K + m + 1 = ↑K + 1 + m | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ ↑K + m + 1 = ↑K.succ + m
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffIteratedDeriv | [65, 1] | [73, 12] | ring | n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ ↑K + m + 1 = ↑K + 1 + m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℕ+
m : ℤ
K : ℕ
Kih : iteratedDeriv K (RuesDiff n m) = RuesDiff n (↑K + m)
h₀ : deriv (iteratedDeriv K (RuesDiff n m)) = deriv (RuesDiff n (↑K + m))
⊢ ↑K + m + 1 = ↑K + 1 + m
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₀ : (n : ℕ) ≠ 0 := PNat.ne_zero n | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | let nMul : ℕ → ℕ := (λ (m : ℕ) => (n : ℕ) * m) | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have hnMulInj := mul_right_injective₀ h₀ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k) := by exact rfl | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : Set.range nMul), f ↑a := by
exact Eq.symm (tsum_range f hnMulInj) | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rw [h₁, h₂, _root_.tsum_subtype (Set.range nMul) f] | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∑' (x : ℕ), (Set.range nMul).indicator f x = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact tsum_congr (h₃) | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
h₃ : ∀ (k : ℕ), (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0
⊢ ∑' (x : ℕ), (Set.range nMul).indicator f x = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
h₃ : ∀ (k : ℕ), (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0
⊢ ∑' (x : ℕ), (Set.range nMul).indicator f x = ∑' (k : ℕ), if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact rfl | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
⊢ ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact Eq.symm (tsum_range f hnMulInj) | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
⊢ ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
⊢ ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | intros k | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∀ (k : ℕ), (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
⊢ ∀ (k : ℕ), (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | simp only [Set.indicator, Set.mem_range, eq_comm, Dvd.dvd, nMul] | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (if ∃ c, ↑k = ↑↑n * c then f k else 0) = if ∃ y, k = ↑n * y then f k else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (Set.range nMul).indicator f k = if ↑↑n ∣ ↑k then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | congr 1 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (if ∃ c, ↑k = ↑↑n * c then f k else 0) = if ∃ y, k = ↑n * y then f k else 0 | case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) = ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (if ∃ c, ↑k = ↑↑n * c then f k else 0) = if ∃ y, k = ↑n * y then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rw [←iff_eq_eq] | case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) = ∃ y, k = ↑n * y | case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) ↔ ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) = ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | constructor | case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) ↔ ∃ y, k = ↑n * y | case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) → ∃ y, k = ↑n * y
case e_c.mpr
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ y, k = ↑n * y) → ∃ c, ↑k = ↑↑n * c | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) ↔ ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | intros h₀ | case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) → ∃ y, k = ↑n * y | case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀✝ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
h₀ : ∃ c, ↑k = ↑↑n * c
⊢ ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
⊢ (∃ c, ↑k = ↑↑n * c) → ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rcases h₀ with ⟨w, hw⟩ | case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀✝ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
h₀ : ∃ c, ↑k = ↑↑n * c
⊢ ∃ y, k = ↑n * y | case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mp
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀✝ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
h₀ : ∃ c, ↑k = ↑↑n * c
⊢ ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₁ : ∃ (w₂ : ℕ), w = w₂ := by
refine Int.eq_ofNat_of_zero_le ?_
by_contra h₆
simp only [not_le] at h₆
have h₃ : (n : ℤ) > 0 := by
refine Int.ofNat_pos.mpr ?_
exact PNat.pos n
have h₄ : ((n : ℤ) * w) < 0 := by
exact Int.mul_neg_of_pos_of_neg h₃ h₆
linarith | case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ ∃ y, k = ↑n * y | case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁✝ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₁ : ∃ w₂, w = ↑w₂
⊢ ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rcases h₁ with ⟨w₂, hw₂⟩ | case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁✝ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₁ : ∃ w₂, w = ↑w₂
⊢ ∃ y, k = ↑n * y | case e_c.mp.intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ ∃ y, k = ↑n * y | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mp.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁✝ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₁ : ∃ w₂, w = ↑w₂
⊢ ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | use w₂ | case e_c.mp.intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ ∃ y, k = ↑n * y | case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mp.intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ ∃ y, k = ↑n * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rw [hw₂] at hw | case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂ | case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
w₂ : ℕ
hw : ↑k = ↑↑n * ↑w₂
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
w₂ : ℕ
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact Int.ofNat_inj.mp hw | case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
w₂ : ℕ
hw : ↑k = ↑↑n * ↑w₂
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
w₂ : ℕ
hw : ↑k = ↑↑n * ↑w₂
hw₂ : w = ↑w₂
⊢ k = ↑n * w₂
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | refine Int.eq_ofNat_of_zero_le ?_ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ ∃ w₂, w = ↑w₂ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ 0 ≤ w | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ ∃ w₂, w = ↑w₂
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | by_contra h₆ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ 0 ≤ w | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : ¬0 ≤ w
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
⊢ 0 ≤ w
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | simp only [not_le] at h₆ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : ¬0 ≤ w
⊢ False | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : ¬0 ≤ w
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₃ : (n : ℤ) > 0 := by
refine Int.ofNat_pos.mpr ?_
exact PNat.pos n | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ False | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | have h₄ : ((n : ℤ) * w) < 0 := by
exact Int.mul_neg_of_pos_of_neg h₃ h₆ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
⊢ False | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
h₄ : ↑↑n * w < 0
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | linarith | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
h₄ : ↑↑n * w < 0
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
h₃ : ↑↑n > 0
h₄ : ↑↑n * w < 0
⊢ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | refine Int.ofNat_pos.mpr ?_ | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ ↑↑n > 0 | α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ 0 < ↑n | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T2Space α
inst✝ : AddCommMonoid α
f : ℕ → α
n : ℕ+
h₀ : ↑n ≠ 0
nMul : ℕ → ℕ := fun m => ↑n * m
hnMulInj : Function.Injective fun x => ↑n * x
h₁ : ∑' (k : ℕ), f (↑n * k) = ∑' (k : ℕ), f (nMul k)
h₂ : ∑' (k : ℕ), f (nMul k) = ∑' (a : ↑(Set.range nMul)), f ↑a
k : ℕ
w : ℤ
hw : ↑k = ↑↑n * w
h₆ : w < 0
⊢ ↑↑n > 0
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.