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/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact PNat.pos n | Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
w : β€
hw : βk = ββn * w
hβ : w < 0
β’ 0 < βn | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
w : β€
hw : βk = ββn * w
hβ : w < 0
β’ 0 < βn
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | exact Int.mul_neg_of_pos_of_neg hβ hβ | Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
w : β€
hw : βk = ββn * w
hβ : w < 0
hβ : ββn > 0
β’ ββn * w < 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
w : β€
hw : βk = ββn * w
hβ : w < 0
hβ : ββn > 0
β’ ββn * w < 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | intros hβ | case e_c.mpr
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
β’ (β y, k = βn * y) β β c, βk = ββn * c | case e_c.mpr
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
hβ : β y, k = βn * y
β’ β c, βk = ββn * c | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mpr
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
β’ (β y, k = βn * y) β β c, βk = ββn * c
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | rcases hβ with β¨w,hwβ© | case e_c.mpr
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
hβ : β y, k = βn * y
β’ β c, βk = ββn * c | case e_c.mpr.intro
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ β c, βk = ββn * c | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mpr
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k : β
hβ : β y, k = βn * y
β’ β c, βk = ββn * c
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | use w | case e_c.mpr.intro
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ β c, βk = ββn * c | case h
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ βk = ββn * βw | Please generate a tactic in lean4 to solve the state.
STATE:
case e_c.mpr.intro
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ β c, βk = ββn * c
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | TsumMulIte | [75, 1] | [110, 24] | simp only [Nat.cast_mul, hw] | case h
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ βk = ββn * βw | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type u_1
instβΒ² : TopologicalSpace Ξ±
instβΒΉ : T2Space Ξ±
instβ : AddCommMonoid Ξ±
f : β β Ξ±
n : β+
hβ : βn β 0
nMul : β β β := fun m => βn * m
hnMulInj : Function.Injective fun x => βn * x
hβ : β' (k : β), f (βn * k) = β' (k : β), f (nMul k)
hβ : β' (k : β), f (nMul k) = β' (a : β(Set.range nMul)), f βa
k w : β
hw : k = βn * w
β’ βk = ββn * βw
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | NeedZeroCoeff | [112, 1] | [113, 21] | exact TsumMulIte _ | f : β β β
n : β+
β’ β' (k : β), f (βn * k) = β' (k : β), if ββn β£ βk then f k else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : β β β
n : β+
β’ β' (k : β), f (βn * k) = β' (k : β), if ββn β£ βk then f k else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffM0EqualsRues | [115, 1] | [119, 64] | ext1 z | n : β+
β’ RuesDiff n 0 = Rues n | case h
n : β+
z : β
β’ RuesDiff n 0 z = Rues n z | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
β’ RuesDiff n 0 = Rues n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffM0EqualsRues | [115, 1] | [119, 64] | rw [Rues, RuesDiff] | case h
n : β+
z : β
β’ RuesDiff n 0 z = Rues n z | case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk + 0 then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
case h
n : β+
z : β
β’ RuesDiff n 0 z = Rues n z
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffM0EqualsRues | [115, 1] | [119, 64] | simp only [add_zero] | case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk + 0 then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial | case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial | Please generate a tactic in lean4 to solve the state.
STATE:
case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk + 0 then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffM0EqualsRues | [115, 1] | [119, 64] | rw [NeedZeroCoeff (Ξ» (k : β) => z ^ k / (Nat.factorial k)) n] | case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
n : β+
z : β
β’ (β' (k : β), if ββn β£ βk then z ^ k / βk.factorial else 0) = β' (k : β), z ^ (βn * k) / β(βn * k).factorial
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp_rw [RuesDiff, βtsum_mul_left] | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ RuesDiff n m (z * rou) = rou ^ (-m) * RuesDiff n m z | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (β' (k : β), if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
β' (x : β), rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ RuesDiff n m (z * rou) = rou ^ (-m) * RuesDiff n m z
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | congr | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (β' (k : β), if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
β' (x : β), rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0 | case e_f
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (fun k => if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) = fun x =>
rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (β' (k : β), if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
β' (x : β), rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | ext1 k | case e_f
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (fun k => if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) = fun x =>
rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0 | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
rou ^ (-m) * if ββn β£ βk + m then z ^ k / βk.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
β’ (fun k => if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) = fun x =>
rou ^ (-m) * if ββn β£ βx + m then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp only [zpow_neg, mul_ite, mul_zero] | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
rou ^ (-m) * if ββn β£ βk + m then z ^ k / βk.factorial else 0 | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
rou ^ (-m) * if ββn β£ βk + m then z ^ k / βk.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ := Classical.em (ββn β£ βk + m) | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβ : ββn β£ βk + m β¨ Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rcases hβ with hβa | hβb | case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβ : ββn β£ βk + m β¨ Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0
case e_f.h.inr
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβb : Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβ : ββn β£ βk + m β¨ Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp_rw [if_pos hβa] | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (z * rou) ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rw [mul_pow z rou k] | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (z * rou) ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ (z * rou) ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ : rou ^ k = (rou ^ m)β»ΒΉ := by
obtain β¨kβ, kmDivβ© := hβa
have hβ : rou ^ (βk + m) = 1 := by
rw [kmDiv, zpow_mul]
simp only [zpow_natCast, h, one_zpow]
have hβ := congrArg (Ξ» (zβ : β) => zβ * (rou ^ m)β»ΒΉ) hβ
simp only [one_mul, ne_eq, inv_eq_zero] at hβ
have hβ := RouNot0 n rou h
rw [zpow_addβ hβ βk m] at hβ
rw [βhβ]
have hβ
: rou ^ m β 0 := by
exact zpow_ne_zero m hβ
field_simp | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rw [hβ] | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * (rou ^ m)β»ΒΉ / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * rou ^ k / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | ring | case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * (rou ^ m)β»ΒΉ / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inl
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
hβ : rou ^ k = (rou ^ m)β»ΒΉ
β’ z ^ k * (rou ^ m)β»ΒΉ / βk.factorial = (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | obtain β¨kβ, kmDivβ© := hβa | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβa : ββn β£ βk + m
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ : rou ^ (βk + m) = 1 := by
rw [kmDiv, zpow_mul]
simp only [zpow_natCast, h, one_zpow] | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ := congrArg (Ξ» (zβ : β) => zβ * (rou ^ m)β»ΒΉ) hβ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : (fun zβ => zβ * (rou ^ m)β»ΒΉ) (rou ^ (βk + m)) = (fun zβ => zβ * (rou ^ m)β»ΒΉ) 1
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp only [one_mul, ne_eq, inv_eq_zero] at hβ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : (fun zβ => zβ * (rou ^ m)β»ΒΉ) (rou ^ (βk + m)) = (fun zβ => zβ * (rou ^ m)β»ΒΉ) 1
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : (fun zβ => zβ * (rou ^ m)β»ΒΉ) (rou ^ (βk + m)) = (fun zβ => zβ * (rou ^ m)β»ΒΉ) 1
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ := RouNot0 n rou h | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rw [zpow_addβ hβ βk m] at hβ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ (βk + m) * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rw [βhβ] | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | have hβ
: rou ^ m β 0 := by
exact zpow_ne_zero m hβ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
hβ
: rou ^ m β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | field_simp | case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
hβ
: rou ^ m β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
hβ
: rou ^ m β 0
β’ rou ^ k = rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | rw [kmDiv, zpow_mul] | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ rou ^ (βk + m) = 1 | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ (rou ^ ββn) ^ kβ = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ rou ^ (βk + m) = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp only [zpow_natCast, h, one_zpow] | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ (rou ^ ββn) ^ kβ = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
β’ (rou ^ ββn) ^ kβ = 1
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | exact zpow_ne_zero m hβ | n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ m β 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
kβ : β€
kmDiv : βk + m = ββn * kβ
hβ : rou ^ (βk + m) = 1
hβ : rou ^ βk * rou ^ m * (rou ^ m)β»ΒΉ = (rou ^ m)β»ΒΉ
hβ : rou β 0
β’ rou ^ m β 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffRotationallySymmetric | [121, 1] | [145, 25] | simp_rw [if_neg hβb] | case e_f.h.inr
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβb : Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.inr
n : β+
m : β€
z rou : β
h : rou ^ βn = 1
k : β
hβb : Β¬ββn β£ βk + m
β’ (if ββn β£ βk + m then (z * rou) ^ k / βk.factorial else 0) =
if ββn β£ βk + m then (rou ^ m)β»ΒΉ * (z ^ k / βk.factorial) else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | have hβ : n β£ (k * n) := by
exact Int.dvd_mul_left k n | n m k : β€
β’ n β£ m β n β£ m + k * n | n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : β€
β’ n β£ m β n β£ m + k * n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | constructor | n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n | case mp
n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n
case mpr
n m k : β€
hβ : n β£ k * n
β’ n β£ m + k * n β n β£ m | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | exact Int.dvd_mul_left k n | n m k : β€
β’ n β£ k * n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : β€
β’ n β£ k * n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | intros hβ | case mp
n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n | case mp
n m k : β€
hβ : n β£ k * n
hβ : n β£ m
β’ n β£ m + k * n | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
n m k : β€
hβ : n β£ k * n
β’ n β£ m β n β£ m + k * n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | exact Dvd.dvd.add hβ hβ | case mp
n m k : β€
hβ : n β£ k * n
hβ : n β£ m
β’ n β£ m + k * n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
n m k : β€
hβ : n β£ k * n
hβ : n β£ m
β’ n β£ m + k * n
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | intros hβ | case mpr
n m k : β€
hβ : n β£ k * n
β’ n β£ m + k * n β n β£ m | case mpr
n m k : β€
hβ : n β£ k * n
hβ : n β£ m + k * n
β’ n β£ m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
n m k : β€
hβ : n β£ k * n
β’ n β£ m + k * n β n β£ m
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | Dvd.dvd.addMultiple | [147, 1] | [154, 38] | exact (Int.dvd_add_left hβ).mp hβ | case mpr
n m k : β€
hβ : n β£ k * n
hβ : n β£ m + k * n
β’ n β£ m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
n m k : β€
hβ : n β£ k * n
hβ : n β£ m + k * n
β’ n β£ m
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | ext1 z | n : β+
m k : β€
β’ RuesDiff n m = RuesDiff n (m + k * ββn) | case h
n : β+
m k : β€
z : β
β’ RuesDiff n m z = RuesDiff n (m + k * ββn) z | Please generate a tactic in lean4 to solve the state.
STATE:
n : β+
m k : β€
β’ RuesDiff n m = RuesDiff n (m + k * ββn)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | simp_rw [RuesDiff] | case h
n : β+
m k : β€
z : β
β’ RuesDiff n m z = RuesDiff n (m + k * ββn) z | case h
n : β+
m k : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (k_1 : β), if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
n : β+
m k : β€
z : β
β’ RuesDiff n m z = RuesDiff n (m + k * ββn) z
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | congr | case h
n : β+
m k : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (k_1 : β), if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0 | case h.e_f
n : β+
m k : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun k_1 =>
if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
n : β+
m k : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (k_1 : β), if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | ext1 K | case h.e_f
n : β+
m k : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun k_1 =>
if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0 | case h.e_f.h
n : β+
m k : β€
z : β
K : β
β’ (if ββn β£ βK + m then z ^ K / βK.factorial else 0) = if ββn β£ βK + (m + k * ββn) then z ^ K / βK.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e_f
n : β+
m k : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun k_1 =>
if ββn β£ βk_1 + (m + k * ββn) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | congr 1 | case h.e_f.h
n : β+
m k : β€
z : β
K : β
β’ (if ββn β£ βK + m then z ^ K / βK.factorial else 0) = if ββn β£ βK + (m + k * ββn) then z ^ K / βK.factorial else 0 | case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m) = (ββn β£ βK + (m + k * ββn)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e_f.h
n : β+
m k : β€
z : β
K : β
β’ (if ββn β£ βK + m then z ^ K / βK.factorial else 0) = if ββn β£ βK + (m + k * ββn) then z ^ K / βK.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | rw [Dvd.dvd.addMultiple (ββn) (βK + m) k] | case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m) = (ββn β£ βK + (m + k * ββn)) | case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m + k * ββn) = (ββn β£ βK + (m + k * ββn)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m) = (ββn β£ βK + (m + k * ββn))
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffMPeriodic | [156, 1] | [163, 10] | ring_nf | case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m + k * ββn) = (ββn β£ βK + (m + k * ββn)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e_f.h.e_c
n : β+
m k : β€
z : β
K : β
β’ (ββn β£ βK + m + k * ββn) = (ββn β£ βK + (m + k * ββn))
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp_rw [RuesDiff] | n k : β+
m : β€
z : β
β’ RuesDiff n m z = β kβ β range βk, RuesDiff (n * k) (ββn * βkβ + m) z | n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
β’ RuesDiff n m z = β kβ β range βk, RuesDiff (n * k) (ββn * βkβ + m) z
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : β x β range k, Summable (Ξ» (k_1 : β) => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0) := by
intros x _
exact RuesDiffSummable (n * k) _ z | n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [β tsum_sum hβ] | n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β x β range βk, β' (k_1 : β), if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear hβ | n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
hβ : β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | congr | n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | case e_f
n k : β+
m : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun b =>
β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
β’ (β' (k : β), if ββn β£ βk + m then z ^ k / βk.factorial else 0) =
β' (b : β), β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | ext1 x | case e_f
n k : β+
m : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun b =>
β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f
n k : β+
m : β€
z : β
β’ (fun k => if ββn β£ βk + m then z ^ k / βk.factorial else 0) = fun b =>
β i β range βk, if ββ(n * k) β£ βb + (ββn * βi + m) then z ^ b / βb.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | let fβ : β β Prop := (Ξ» (i : β) => ββ(n * k) β£ βx + (ββn * βi + m)) | case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j := by
intros i hir j hjr hi hj
simp [fβ] at hi hj
simp only [mem_range] at hir hjr
clear fβ z
rw [βInt.modEq_zero_iff_dvd] at hi hj
have hβ := Int.ModEq.sub hi hj
simp only [add_sub_add_left_eq_sub, add_sub_add_right_eq_sub, sub_self] at hβ
clear hi hj
rw [Int.modEq_zero_iff_dvd, (show (ββn * βi - ββn * βj : β€) = ββn * (βi - βj) by ring)] at hβ
have hβ : (n : β€) β 0 := by
exact Ne.symm (NeZero.ne' (n : β€))
have hβ : (k : β€) β£ βi - βj := by exact (mul_dvd_mul_iff_left hβ).mp hβ
obtain β¨y, hββ© := hβ
have hβ : k * y < k := by
linarith
have hβ
: -k < k * y := by
linarith
have hβ : (k : β€) > 0 := by
linarith
have hβ : y < 1 := by
exact (mul_lt_iff_lt_one_right hβ).mp hβ
nth_rw 1 [(show -(k : β€) = ββk * -1 by ring)] at hβ
have hβ : -1 < y := by
exact (mul_lt_mul_left hβ).mp hβ
have hβ : y = 0 := by
linarith
rw [hβ] at hβ
simp only [mul_zero] at hβ
clear n hir hjr m hβ hβ hβ hβ
hβ hβ hβ hβ y x k
refine Int.ofNat_inj.mp ?intro.a
have hβ := congrArg (Ξ» (k : β€) => k + j) hβ
simp only [sub_add_cancel, zero_add] at hβ
exact hβ | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ := Finset.sum_ite_zero (range βk) fβ hβ (z ^ x / βx.factorial) | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear hβ | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ : β i β range βk, β j β range βk, fβ i β fβ j β i = j
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp only [PNat.mul_coe, Nat.cast_mul, mem_range, fβ] at hβ β’ | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β i β range βk, if fβ i then z ^ x / βx.factorial else 0) = if β i β range βk, fβ i then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β i β range βk, if ββ(n * k) β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [hβ] | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear hβ fβ | case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
hβ :
(β x_1 β range βk, if ββn * ββk β£ βx + (ββn * βx_1 + m) then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | congr | case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0 | case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ (ββn β£ βx + m) = β i < βk, ββn * ββk β£ βx + (ββn * βi + m) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h
n k : β+
m : β€
z : β
x : β
β’ (if ββn β£ βx + m then z ^ x / βx.factorial else 0) =
if β i < βk, ββn * ββk β£ βx + (ββn * βi + m) then z ^ x / βx.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [βiff_eq_eq] | case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ (ββn β£ βx + m) = β i < βk, ββn * ββk β£ βx + (ββn * βi + m) | case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ ββn β£ βx + m β β i < βk, ββn * ββk β£ βx + (ββn * βi + m) | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ (ββn β£ βx + m) = β i < βk, ββn * ββk β£ βx + (ββn * βi + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | constructor | case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ ββn β£ βx + m β β i < βk, ββn * ββk β£ βx + (ββn * βi + m) | case e_f.h.e_c.mp
n k : β+
m : β€
z : β
x : β
β’ ββn β£ βx + m β β i < βk, ββn * ββk β£ βx + (ββn * βi + m)
case e_f.h.e_c.mpr
n k : β+
m : β€
z : β
x : β
β’ (β i < βk, ββn * ββk β£ βx + (ββn * βi + m)) β ββn β£ βx + m | Please generate a tactic in lean4 to solve the state.
STATE:
case e_f.h.e_c
n k : β+
m : β€
z : β
x : β
β’ ββn β£ βx + m β β i < βk, ββn * ββk β£ βx + (ββn * βi + m)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | intros x _ | n k : β+
m : β€
z : β
β’ β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | n k : β+
m : β€
z : β
x : β
aβ : x β range βk
β’ Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
β’ β x β range βk, Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | exact RuesDiffSummable (n * k) _ z | n k : β+
m : β€
z : β
x : β
aβ : x β range βk
β’ Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
x : β
aβ : x β range βk
β’ Summable fun k_1 => if ββ(n * k) β£ βk_1 + (ββn * βx + m) then z ^ k_1 / βk_1.factorial else 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | intros i hir j hjr hi hj | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
β’ β i β range βk, β j β range βk, fβ i β fβ j β i = j | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : fβ i
hj : fβ j
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
β’ β i β range βk, β j β range βk, fβ i β fβ j β i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp [fβ] at hi hj | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : fβ i
hj : fβ j
β’ i = j | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : fβ i
hj : fβ j
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp only [mem_range] at hir hjr | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
β’ i = j | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i : β
hir : i β range βk
j : β
hjr : j β range βk
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear fβ z | n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j | n k : β+
m : β€
x i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
z : β
x : β
fβ : β β Prop := fun i => ββ(n * k) β£ βx + (ββn * βi + m)
i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [βInt.modEq_zero_iff_dvd] at hi hj | n k : β+
m : β€
x i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hi : ββn * ββk β£ βx + (ββn * βi + m)
hj : ββn * ββk β£ βx + (ββn * βj + m)
hir : i < βk
hjr : j < βk
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ := Int.ModEq.sub hi hj | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
β’ i = j | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : βx + (ββn * βi + m) - (βx + (ββn * βj + m)) β‘ 0 - 0 [ZMOD ββn * ββk]
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp only [add_sub_add_left_eq_sub, add_sub_add_right_eq_sub, sub_self] at hβ | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : βx + (ββn * βi + m) - (βx + (ββn * βj + m)) β‘ 0 - 0 [ZMOD ββn * ββk]
β’ i = j | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : βx + (ββn * βi + m) - (βx + (ββn * βj + m)) β‘ 0 - 0 [ZMOD ββn * ββk]
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear hi hj | n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hi : βx + (ββn * βi + m) β‘ 0 [ZMOD ββn * ββk]
hj : βx + (ββn * βj + m) β‘ 0 [ZMOD ββn * ββk]
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [Int.modEq_zero_iff_dvd, (show (ββn * βi - ββn * βj : β€) = ββn * (βi - βj) by ring)] at hβ | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * βi - ββn * βj β‘ 0 [ZMOD ββn * ββk]
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : (n : β€) β 0 := by
exact Ne.symm (NeZero.ne' (n : β€)) | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
β’ i = j | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : (k : β€) β£ βi - βj := by exact (mul_dvd_mul_iff_left hβ).mp hβ | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
β’ i = j | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
hβ : ββk β£ βi - βj
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | obtain β¨y, hββ© := hβ | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
hβ : ββk β£ βi - βj
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
hβ : ββk β£ βi - βj
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : k * y < k := by
linarith | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ
: -k < k * y := by
linarith | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : (k : β€) > 0 := by
linarith | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : y < 1 := by
exact (mul_lt_iff_lt_one_right hβ).mp hβ | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | nth_rw 1 [(show -(k : β€) = ββk * -1 by ring)] at hβ
| case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : -1 < y := by
exact (mul_lt_mul_left hβ).mp hβ
| case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ : y = 0 := by
linarith | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | rw [hβ] at hβ | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * 0
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp only [mul_zero] at hβ | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * 0
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
hβ : βi - βj = 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * 0
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | clear n hir hjr m hβ hβ hβ hβ
hβ hβ hβ hβ y x k | case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
hβ : βi - βj = 0
β’ i = j | case intro
i j : β
hβ : βi - βj = 0
β’ i = j | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : ββk * y < ββk
hβ
: ββk * -1 < ββk * y
hβ : ββk > 0
hβ : y < 1
hβ : -1 < y
hβ : y = 0
hβ : βi - βj = 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | refine Int.ofNat_inj.mp ?intro.a | case intro
i j : β
hβ : βi - βj = 0
β’ i = j | case intro.a
i j : β
hβ : βi - βj = 0
β’ βi = βj | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
i j : β
hβ : βi - βj = 0
β’ i = j
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | have hβ := congrArg (Ξ» (k : β€) => k + j) hβ | case intro.a
i j : β
hβ : βi - βj = 0
β’ βi = βj | case intro.a
i j : β
hβ : βi - βj = 0
hβ : (fun k => k + βj) (βi - βj) = (fun k => k + βj) 0
β’ βi = βj | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.a
i j : β
hβ : βi - βj = 0
β’ βi = βj
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | simp only [sub_add_cancel, zero_add] at hβ | case intro.a
i j : β
hβ : βi - βj = 0
hβ : (fun k => k + βj) (βi - βj) = (fun k => k + βj) 0
β’ βi = βj | case intro.a
i j : β
hβ : βi - βj = 0
hβ : βi = βj
β’ βi = βj | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.a
i j : β
hβ : βi - βj = 0
hβ : (fun k => k + βj) (βi - βj) = (fun k => k + βj) 0
β’ βi = βj
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | exact hβ | case intro.a
i j : β
hβ : βi - βj = 0
hβ : βi = βj
β’ βi = βj | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.a
i j : β
hβ : βi - βj = 0
hβ : βi = βj
β’ βi = βj
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | ring | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * βi - ββn * βj
β’ ββn * βi - ββn * βj = ββn * (βi - βj) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * βi - ββn * βj
β’ ββn * βi - ββn * βj = ββn * (βi - βj)
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | exact Ne.symm (NeZero.ne' (n : β€)) | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
β’ ββn β 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
β’ ββn β 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | exact (mul_dvd_mul_iff_left hβ).mp hβ | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
β’ ββk β£ βi - βj | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
β’ ββk β£ βi - βj
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | linarith | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
β’ ββk * y < ββk | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
β’ ββk * y < ββk
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | linarith | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
β’ -ββk < ββk * y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
β’ -ββk < ββk * y
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | linarith | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
β’ ββk > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
β’ ββk > 0
TACTIC:
|
https://github.com/Nazgand/NazgandLean4.git | a6c5455a06d14c59786b1c23c2d20dada7598be6 | NazgandLean4/RootOfUnityExponentialSum.lean | RuesDiffSumOfRuesDiff | [165, 1] | [256, 48] | exact (mul_lt_iff_lt_one_right hβ).mp hβ | n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
β’ y < 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k : β+
m : β€
x i j : β
hir : i < βk
hjr : j < βk
hβ : ββn * ββk β£ ββn * (βi - βj)
hβ : ββn β 0
y : β€
hβ : βi - βj = ββk * y
hβ : ββk * y < ββk
hβ
: -ββk < ββk * y
hβ : ββk > 0
β’ y < 1
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.