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/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | field_simp | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ fβ ((t + 2 * βΟ / ββkβ) * ββkβ / ββkβ) ^ βkβ = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ fβ ((t * ββkβ + 2 * βΟ) / ββkβ) ^ βkβ = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ fβ ((t + 2 * βΟ / ββkβ) * ββkβ / ββkβ) ^ βkβ = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | rw [(show (t * ββkβ + 2 * βΟ) / ββkβ = t * ββkβ / ββkβ + 2 * βΟ / ββkβ by ring), hβ, mul_pow, βComplex.exp_nat_mul] | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ fβ ((t * ββkβ + 2 * βΟ) / ββkβ) ^ βkβ = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) * fβ (t * ββkβ / ββkβ) ^ βkβ =
cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ fβ ((t * ββkβ + 2 * βΟ) / ββkβ) ^ βkβ = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | congr 1 | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) * fβ (t * ββkβ / ββkβ) ^ βkβ =
cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ | case e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) * fβ (t * ββkβ / ββkβ) ^ βkβ =
cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) * fβ (t * ββkβ / ββkβ) ^ βkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | congr 1 | case e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ) | case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * (I * 2 * βm * βΟ / ββkβ) = I * 2 * (βm * ββkβ) * βΟ / ββkβ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ cexp (ββkβ * (I * 2 * βm * βΟ / ββkβ)) = cexp (I * 2 * (βm * ββkβ) * βΟ / ββkβ)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | ring_nf | case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * (I * 2 * βm * βΟ / ββkβ) = I * 2 * (βm * ββkβ) * βΟ / ββkβ | case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ * 2 = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * (I * 2 * βm * βΟ / ββkβ) = I * 2 * (βm * ββkβ) * βΟ / ββkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | congr 1 | case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ * 2 = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ * 2 | case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_z
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ * 2 = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | field_simp | case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ | case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ = I * βm * βΟ * ββkβ | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ * (ββkβ)β»ΒΉ = I * βm * βΟ * ββkβ * (ββkβ)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | ring_nf | case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ = I * βm * βΟ * ββkβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_a.e_z.e_a
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ ββkβ * I * βm * βΟ = I * βm * βΟ * ββkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated | [122, 1] | [133, 10] | ring | fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ (t * ββkβ + 2 * βΟ) / ββkβ = t * ββkβ / ββkβ + 2 * βΟ / ββkβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
kβ kβ : β+
m : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββkβ) = cexp (I * 2 * βm * βΟ / ββkβ) * fβ t
t : β
β’ (t * ββkβ + 2 * βΟ) / ββkβ = t * ββkβ / ββkβ + 2 * βΟ / ββkβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | simp [SetSpiro] at * | fβ : β β β
k : β+
mβ mβ : β€
hβ : fβ β SetSpiro k mβ
β’ (fun t => cexp (I * t * (βmβ - βmβ)) * fβ t) β SetSpiro k mβ | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
β’ β (t : β),
cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : fβ β SetSpiro k mβ
β’ (fun t => cexp (I * t * (βmβ - βmβ)) * fβ t) β SetSpiro k mβ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | intros t | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
β’ β (t : β),
cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
β’ β (t : β),
cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | rw [hβ] | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * (cexp (I * 2 * βmβ * βΟ / ββk) * fβ t) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * fβ (t + 2 * βΟ / ββk) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | ring_nf | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * (cexp (I * 2 * βmβ * βΟ / ββk) * fβ t) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t) | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2)) *
cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * (t + 2 * βΟ / ββk) * (βmβ - βmβ)) * (cexp (I * 2 * βmβ * βΟ / ββk) * fβ t) =
cexp (I * 2 * βmβ * βΟ / ββk) * (cexp (I * t * (βmβ - βmβ)) * fβ t)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | rw [βComplex.exp_add, (show fβ t * (I * βΟ * (ββk)β»ΒΉ * βmβ * 2).exp * (I * t * βmβ - I * t * βmβ).exp =
fβ t * ((I * βΟ * (ββk)β»ΒΉ * βmβ * 2).exp * (I * t * βmβ - I * t * βmβ).exp) by ring), βComplex.exp_add] | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2)) *
cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ) | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp
(I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2) +
I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 + (I * t * βmβ - I * t * βmβ)) | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp (I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2)) *
cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | ring_nf | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp
(I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2) +
I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 + (I * t * βmβ - I * t * βmβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ cexp
(I * t * βmβ - I * t * βmβ + (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 - I * βΟ * (ββk)β»ΒΉ * βmβ * 2) +
I * βΟ * (ββk)β»ΒΉ * βmβ * 2) *
fβ t =
fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2 + (I * t * βmβ - I * t * βmβ))
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/SymmetricSpirographs.lean | SetSpiroRelated2 | [135, 1] | [143, 10] | ring | fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ) =
fβ t * (cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
fβ : β β β
k : β+
mβ mβ : β€
hβ : β (t : β), fβ (t + 2 * βΟ / ββk) = cexp (I * 2 * βmβ * βΟ / ββk) * fβ t
t : β
β’ fβ t * cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ) =
fβ t * (cexp (I * βΟ * (ββk)β»ΒΉ * βmβ * 2) * cexp (I * t * βmβ - I * t * βmβ))
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ext β¨r, x, y, zβ© | β’ Soqtstn1β = Soqtstn1β | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β | Please generate a tactic in lean4 to solve the state.
STATE:
β’ Soqtstn1β = Soqtstn1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | dsimp [Soqtstn1β, Soqtstn1β] | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β | case h.mk
r x y z : β
β’ -1 = { re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [ext_iff, neg_re, QuaternionAlgebra.one_re, mul_re, neg_imI, QuaternionAlgebra.one_imI,
neg_zero, mul_imI, neg_imJ, QuaternionAlgebra.one_imJ, mul_imJ, neg_imK,
QuaternionAlgebra.one_imK, mul_imK] | case h.mk
r x y z : β
β’ -1 = { re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1 | case h.mk
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ -1 = { re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | constructor | case h.mk
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h.mk.mp
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
case h.mk.mpr
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | intros ha | case h.mk.mp
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h.mk.mp
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | use x | case h.mk.mp
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | use y | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1 | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | use z | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1 | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [and_self, and_true] | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1 | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rcases ha with β¨hSphere3, h0x, h0y, h0zβ© | case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x + x * r + y * z - z * y
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
ha :
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring_nf at h0x | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x + x * r + y * z - z * y
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x + x * r + y * z - z * y
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring_nf at h0y | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y - x * z + y * r + z * x
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring_nf at h0z | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z + x * y - y * x + z * r
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [zero_eq_mul, mul_eq_zero, OfNat.ofNat_ne_zero, or_false] at h0x | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : 0 = r * x * 2
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [zero_eq_mul, mul_eq_zero, OfNat.ofNat_ne_zero, or_false] at h0y | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : 0 = r * y * 2
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [zero_eq_mul, mul_eq_zero, OfNat.ofNat_ne_zero, or_false] at h0z | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : 0 = r * z * 2
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | have hrβ : (Β¬ r = 0) β False := by
intros hrn0
let hrn0β := Iff.mpr iff_false_iff hrn0
simp only [hrn0β, false_or] at h0x
simp only [hrn0β, false_or] at h0y
simp only [hrn0β, false_or] at h0z
simp_rw [h0x, h0y, h0z] at hSphere3
simp only [mul_zero, sub_zero] at hSphere3
have hrnn := mul_self_nonneg r
rw [βhSphere3] at hrnn
linarith | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | have hr : r = 0 := by_contra hrβ | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | constructor | case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0 β§ x * x + y * y + z * z = 1 | case h.intro.intro.intro.left
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0 β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | intros hrn0 | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
β’ Β¬r = 0 β False | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
β’ Β¬r = 0 β False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | let hrn0β := Iff.mpr iff_false_iff hrn0 | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
β’ False | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [hrn0β, false_or] at h0x | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
β’ False | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [hrn0β, false_or] at h0y | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
β’ False | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [hrn0β, false_or] at h0z | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
β’ False | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0z : r = 0 β¨ z = 0
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp_rw [h0x, h0y, h0z] at hSphere3 | r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
β’ False | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r - 0 * 0 - 0 * 0 - 0 * 0
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [mul_zero, sub_zero] at hSphere3 | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r - 0 * 0 - 0 * 0 - 0 * 0
β’ False | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r - 0 * 0 - 0 * 0 - 0 * 0
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | have hrnn := mul_self_nonneg r | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
β’ False | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ r * r
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rw [βhSphere3] at hrnn | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ r * r
β’ False | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ -1
β’ False | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ r * r
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | linarith | r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ -1
β’ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
r x y z : β
hrn0 : Β¬r = 0
hrn0β : r = 0 β False := iff_false_iff.mpr hrn0
h0x : x = 0
h0y : y = 0
h0z : z = 0
hSphere3 : -1 = r * r
hrnn : 0 β€ -1
β’ False
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | exact hr | case h.intro.intro.intro.left
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.left
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rw [hr] at hSphere3 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = r * r - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | let hSphere4 := congrArg (Ξ» (xk : β) => -xk) hSphere3 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : (fun xk => -xk) (-1) = (fun xk => -xk) (0 * 0 - x * x - y * y - z * z) := congrArg (fun xk => -xk) hSphere3
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [neg_neg, mul_zero, zero_sub, neg_sub] at hSphere4 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : (fun xk => -xk) (-1) = (fun xk => -xk) (0 * 0 - x * x - y * y - z * z) := congrArg (fun xk => -xk) hSphere3
β’ x * x + y * y + z * z = 1 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : (fun xk => -xk) (-1) = (fun xk => -xk) (0 * 0 - x * x - y * y - z * z) := congrArg (fun xk => -xk) hSphere3
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rw [hSphere4] | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = 1 | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = z * z - (-(x * x) - y * y) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring_nf | case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = z * z - (-(x * x) - y * y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.intro.intro.intro.right
r x y z : β
hSphere3 : -1 = 0 * 0 - x * x - y * y - z * z
h0x : r = 0 β¨ x = 0
h0y : r = 0 β¨ y = 0
h0z : r = 0 β¨ z = 0
hrβ : Β¬r = 0 β False
hr : r = 0
hSphere4 : 1 = z * z - (-(x * x) - y * y)
β’ x * x + y * y + z * z = z * z - (-(x * x) - y * y)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | intros hβ | case h.mk.mpr
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r | case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
-1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring_nf | case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r | case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r * r - x * x - y * y - z * z β§
0 = r * x + x * r + y * z - z * y β§ 0 = r * y - x * z + y * r + z * x β§ 0 = r * z + x * y - y * x + z * r
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rcases hβ with β¨rx, ry, rz, hxβ© | case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | case h.mk.mpr.intro.intro.intro
r x y z rx ry rz : β
hx : (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : β
hβ : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rcases hx with β¨hxβ, hSphereβ© | case h.mk.mpr.intro.intro.intro
r x y z rx ry rz : β
hx : (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | case h.mk.mpr.intro.intro.intro.intro
r x y z rx ry rz : β
hxβ : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro
r x y z rx ry rz : β
hx : (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rcases hxβ with β¨hr, hrx, hry, hrzβ© | case h.mk.mpr.intro.intro.intro.intro
r x y z rx ry rz : β
hxβ : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro
r x y z rx ry rz : β
hxβ : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp_rw [hr] | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = 0 ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = 0 * x * 2 β§ 0 = 0 * y * 2 β§ 0 = 0 * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = r * x * 2 β§ 0 = r * y * 2 β§ 0 = r * z * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, zero_sub, zero_mul,
and_self, and_true] | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = 0 ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = 0 * x * 2 β§ 0 = 0 * y * 2 β§ 0 = 0 * z * 2 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -x ^ 2 + (-y ^ 2 - z ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = 0 ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ 0 = 0 * x * 2 β§ 0 = 0 * y * 2 β§ 0 = 0 * z * 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp_rw [hrx,hry,hrz] | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -x ^ 2 + (-y ^ 2 - z ^ 2) | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -x ^ 2 + (-y ^ 2 - z ^ 2)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | let hSphere2 := congrArg (Ξ» (xk : β) => -xk) hSphere | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : (fun xk => -xk) (rx * rx + ry * ry + rz * rz) = (fun xk => -xk) 1 := congrArg (fun xk => -xk) hSphere
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | simp only [neg_add_rev] at hSphere2 | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : (fun xk => -xk) (rx * rx + ry * ry + rz * rz) = (fun xk => -xk) 1 := congrArg (fun xk => -xk) hSphere
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : (fun xk => -xk) (rx * rx + ry * ry + rz * rz) = (fun xk => -xk) 1 := congrArg (fun xk => -xk) hSphere
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | rw [βhSphere2] | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -1 = -rx ^ 2 + (-ry ^ 2 - rz ^ 2)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [10, 1] | [60, 9] | ring | case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -rx ^ 2 + (-ry ^ 2 - rz ^ 2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr : r = 0
hrx : x = rx
hry : y = ry
hrz : z = rz
hSphere2 : -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -1
β’ -(rz * rz) + (-(ry * ry) + -(rx * rx)) = -rx ^ 2 + (-ry ^ 2 - rz ^ 2)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | ext β¨r, x, y, zβ© | β’ Soqtstn1β = Soqtstn1β | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β | Please generate a tactic in lean4 to solve the state.
STATE:
β’ Soqtstn1β = Soqtstn1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | dsimp [Soqtstn1β, Soqtstn1β] | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β | case h.mk
r x y z : β
β’ (β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β β { re := r, imI := x, imJ := y, imK := z } β Soqtstn1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [ext_iff] | case h.mk
r x y z : β
β’ (β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ (β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 0, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | constructor | case h.mk
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk.mp
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
case h.mk.mpr
r x y z : β
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | intros h | case h.mk.mp
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk.mp
r x y z : β
h : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
β’ (β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1) β
β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | rcases h with β¨rx, ry, rz, hx, hSphereβ© | case h.mk.mp
r x y z : β
h : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk.mp.intro.intro.intro.intro
r x y z rx ry rz : β
hx : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
h : β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | rcases hx with β¨hr0, hxrx, hyry, hzrzβ© | case h.mk.mp.intro.intro.intro.intro
r x y z rx ry rz : β
hx : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro
r x y z rx ry rz : β
hx : r = 0 β§ x = rx β§ y = ry β§ z = rz
hSphere : rx * rx + ry * ry + rz * rz = 1
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp_rw [hr0] | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 β§ True | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [and_true] | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 β§ True | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 β§ True
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp_rw [βhxrx, βhyry, βhzrz] at hSphere | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hSphere : rx * rx + ry * ry + rz * rz = 1
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | let hNorm1 := congrArg Real.sqrt hSphere | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = β1 := congrArg Real.sqrt hSphere
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [Real.sqrt_one] at hNorm1 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = β1 := congrArg Real.sqrt hSphere
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = β1 := congrArg Real.sqrt hSphere
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp_rw [βhNorm1] | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1 | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | let hSqrtNormSquare := congrArg Real.sqrt (Quaternion.normSq_eq_norm_mul_self (@QuaternionAlgebra.mk β (-1) (-1) 0 x y z)) | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) =
β(β{ re := 0, imI := x, imJ := y, imK := z }β * β{ re := 0, imI := x, imJ := y, imK := z }β) :=
congrArg Real.sqrt (normSq_eq_norm_mul_self { re := 0, imI := x, imJ := y, imK := z })
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [norm_nonneg, Real.sqrt_mul_self] at hSqrtNormSquare | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) =
β(β{ re := 0, imI := x, imJ := y, imK := z }β * β{ re := 0, imI := x, imJ := y, imK := z }β) :=
congrArg Real.sqrt (normSq_eq_norm_mul_self { re := 0, imI := x, imJ := y, imK := z })
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) =
β(β{ re := 0, imI := x, imJ := y, imK := z }β * β{ re := 0, imI := x, imJ := y, imK := z }β) :=
congrArg Real.sqrt (normSq_eq_norm_mul_self { re := 0, imI := x, imJ := y, imK := z })
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp_rw [βhSqrtNormSquare, Quaternion.normSq_def'] | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z) | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β(0 ^ 2 + x ^ 2 + y ^ 2 + z ^ 2) = β(x * x + y * y + z * z) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β{ re := 0, imI := x, imJ := y, imK := z }β = β(x * x + y * y + z * z)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | ring_nf | case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β(0 ^ 2 + x ^ 2 + y ^ 2 + z ^ 2) = β(x * x + y * y + z * z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp.intro.intro.intro.intro.intro.intro.intro
r x y z rx ry rz : β
hr0 : r = 0
hxrx : x = rx
hyry : y = ry
hzrz : z = rz
hSphere : x * x + y * y + z * z = 1
hNorm1 : β(x * x + y * y + z * z) = 1
hSqrtNormSquare : β(normSq { re := 0, imI := x, imJ := y, imK := z }) = β{ re := 0, imI := x, imJ := y, imK := z }β
β’ β(0 ^ 2 + x ^ 2 + y ^ 2 + z ^ 2) = β(x * x + y * y + z * z)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | intros hβ | case h.mk.mpr
r x y z : β
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h.mk.mpr
r x y z : β
hβ : β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : β
β’ β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0 β
β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | rcases hβ with β¨hNorm1, hr0β© | case h.mk.mpr
r x y z : β
hβ : β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h.mk.mpr.intro
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr
r x y z : β
hβ : β{ re := r, imI := x, imJ := y, imK := z }β = 1 β§ r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | use x | case h.mk.mpr.intro
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mpr.intro
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rx ry rz, (r = 0 β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | use y | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β ry rz, (r = 0 β§ x = x β§ y = ry β§ z = rz) β§ x * x + ry * ry + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | use z | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ β rz, (r = 0 β§ x = x β§ y = y β§ z = rz) β§ x * x + y * y + rz * rz = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [hr0, and_self, true_and] | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ (r = 0 β§ x = x β§ y = y β§ z = z) β§ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | let hNormSquare1 := congrArg (Ξ» (rβ : β) => rβ * rβ) hNorm1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ x * x + y * y + z * z = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : (fun rβ => rβ * rβ) β{ re := r, imI := x, imJ := y, imK := z }β = (fun rβ => rβ * rβ) 1 :=
congrArg (fun rβ => rβ * rβ) hNorm1
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [mul_one] at hNormSquare1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : (fun rβ => rβ * rβ) β{ re := r, imI := x, imJ := y, imK := z }β = (fun rβ => rβ * rβ) 1 :=
congrArg (fun rβ => rβ * rβ) hNorm1
β’ x * x + y * y + z * z = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : β{ re := r, imI := x, imJ := y, imK := z }β * β{ re := r, imI := x, imJ := y, imK := z }β = 1
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : (fun rβ => rβ * rβ) β{ re := r, imI := x, imJ := y, imK := z }β = (fun rβ => rβ * rβ) 1 :=
congrArg (fun rβ => rβ * rβ) hNorm1
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | rw [βQuaternion.normSq_eq_norm_mul_self, hr0, Quaternion.normSq_def'] at hNormSquare1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : β{ re := r, imI := x, imJ := y, imK := z }β * β{ re := r, imI := x, imJ := y, imK := z }β = 1
β’ x * x + y * y + z * z = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 : β{ re := r, imI := x, imJ := y, imK := z }β * β{ re := r, imI := x, imJ := y, imK := z }β = 1
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | rw [βhNormSquare1] | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = 1 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z =
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | simp only [ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow, zero_add] | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z =
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = x ^ 2 + y ^ 2 + z ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z =
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqtstn1βAndSoqtstn1β | [62, 1] | [91, 12] | ring_nf | case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = x ^ 2 + y ^ 2 + z ^ 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
r x y z : β
hNorm1 : β{ re := r, imI := x, imJ := y, imK := z }β = 1
hr0 : r = 0
hNormSquare1 :
{ re := 0, imI := x, imJ := y, imK := z }.re ^ 2 + { re := 0, imI := x, imJ := y, imK := z }.imI ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imJ ^ 2 +
{ re := 0, imI := x, imJ := y, imK := z }.imK ^ 2 =
1
β’ x * x + y * y + z * z = x ^ 2 + y ^ 2 + z ^ 2
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | ext β¨r, x, y, zβ© | β’ Soqqtstqm1β = Soqqtstqm1β | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β β { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β | Please generate a tactic in lean4 to solve the state.
STATE:
β’ Soqqtstqm1β = Soqqtstqm1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | dsimp [Soqqtstqm1β, Soqqtstqm1β] | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β β { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } - 1 =
{ re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 1 / 2, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β β { re := r, imI := x, imJ := y, imK := z } β Soqqtstqm1β
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | simp only [ext_iff, sub_re, QuaternionAlgebra.one_re, mul_re, sub_imI, QuaternionAlgebra.one_imI,
sub_zero, mul_imI, sub_imJ, QuaternionAlgebra.one_imJ, mul_imJ, sub_imK,
QuaternionAlgebra.one_imK, mul_imK, one_div] | case h.mk
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } - 1 =
{ re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 1 / 2, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk
r x y z : β
β’ r - 1 = r * r - x * x - y * y - z * z β§
x = r * x + x * r + y * z - z * y β§ y = r * y - x * z + y * r + z * x β§ z = r * z + x * y - y * x + z * r β
β 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
r x y z : β
β’ { re := r, imI := x, imJ := y, imK := z } - 1 =
{ re := r, imI := x, imJ := y, imK := z } * { re := r, imI := x, imJ := y, imK := z } β
β rx ry rz,
{ re := r, imI := x, imJ := y, imK := z } = { re := 1 / 2, imI := rx, imJ := ry, imK := rz } β§
rx * rx + ry * ry + rz * rz = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | ring_nf | case h.mk
r x y z : β
β’ r - 1 = r * r - x * x - y * y - z * z β§
x = r * x + x * r + y * z - z * y β§ y = r * y - x * z + y * r + z * x β§ z = r * z + x * y - y * x + z * r β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx * rx + ry * ry + rz * rz = 3 / 4 | case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 1 / 2 β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ r - 1 = r * r - x * x - y * y - z * z β§
x = r * x + x * r + y * z - z * y β§ y = r * y - x * z + y * r + z * x β§ z = r * z + x * y - y * x + z * r β
β 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β | [99, 1] | [154, 9] | simp only [one_div] | case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 1 / 2 β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 1 / 2 β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | constructor | case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | case h.mk.mp
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4
case h.mk.mpr
r x y z : β
β’ (β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4) β
-1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | intros hβ | case h.mk.mp
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | case h.mk.mp
r x y z : β
hβ : -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2
β’ β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
β’ -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2 β
β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/quaternionLemma.lean | EqualSetsSoqqtstqm1βAndSoqqtstqm1β | [99, 1] | [154, 9] | use x | case h.mk.mp
r x y z : β
hβ : -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2
β’ β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | case h
r x y z : β
hβ : -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2
β’ β ry rz, (r = 2β»ΒΉ β§ x = x β§ y = ry β§ z = rz) β§ x ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mk.mp
r x y z : β
hβ : -1 + r = r ^ 2 - x ^ 2 + (-y ^ 2 - z ^ 2) β§ x = r * x * 2 β§ y = r * y * 2 β§ z = r * z * 2
β’ β rx ry rz, (r = 2β»ΒΉ β§ x = rx β§ y = ry β§ z = rz) β§ rx ^ 2 + ry ^ 2 + rz ^ 2 = 3 / 4
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.