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/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | set c := t + 1 - b | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
n3 : t + 1 - b + b = t + 1
n1 : (t + 1 - b) * a + b * (a + 1) = n
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
⊢ a ^ 2 * (t + 1 - b) + b * (a + 1) ^ 2 +
(a ^ 2 * ((t + 1 - b) * (t + 1 - b - 1)) + 2 * (a * (a + 1) * b * (t + 1 - b)) + (a + 1) ^ 2 * (b * (b - 1))) =
((t + 1 - b) * a) ^ 2 + 2 * ((t + 1 - b) * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
n3 : t + 1 - b + b = t + 1
n1 : (t + 1 - b) * a + b * (a + 1) = n
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
⊢ a ^ 2 * (t + 1 - b) + b * (a + 1) ^ 2 +
(a ^ 2 * ((t + 1 - b) * (t + 1 - b - 1)) + 2 * (a * (a + 1) * b * (t + 1 - b)) + (a + 1) ^ 2 * (b * (b - 1))) =
((t + 1 - b) * a) ^ 2 + 2 * ((t + 1 - b) * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | have hc2 : c - 1 + 1 = c := tsub_add_cancel_of_le (tsub_pos_of_lt n2) | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | have hb2 : b - 1 + 1 = b := tsub_add_cancel_of_le hb' | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | rw [add_comm (a^2*c),add_assoc,←add_assoc (a^2*c),←add_assoc (a^2*c),← mul_add (a^2)] | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c + c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * c + b * (a + 1) ^ 2 + (a ^ 2 * (c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | nth_rw 1 [←mul_one c,←mul_add c,add_comm _ (c-1),hc2] | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c + c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c + c * (c - 1)) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | rw [add_comm (b*(a+1)^2),add_assoc,mul_comm b ((a+1)^2),←mul_add ((a+1)^2)] | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ b * (a + 1) ^ 2 + (a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1))) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | nth_rw 4 [←mul_one b] | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b * 1) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb' | [76, 1] | [119, 111] | rw[←mul_add b,hb2,mul_comm c a,mul_pow,←pow_two c,add_assoc,add_assoc,
add_right_inj,mul_pow,mul_add,pow_two,mul_add,mul_one,add_mul,mul_one,pow_two,mul_add,add_mul,
add_mul,add_mul,add_mul,one_mul,mul_one,add_mul,one_mul,mul_add,mul_add,mul_add,mul_add,mul_add,mul_one,
← add_assoc,← add_assoc,← add_assoc,← add_assoc,←add_assoc,add_left_inj,mul_comm a (b*b),add_left_inj,
←add_assoc,add_left_inj,mul_comm (b*b), add_left_inj,mul_assoc 2 _ b,mul_assoc a c b,mul_comm c b,
←mul_assoc a,add_left_inj,mul_assoc 2,mul_assoc,mul_assoc,mul_assoc,mul_comm b a,mul_comm c,mul_assoc] | case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b * 1) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
t n : ℕ
t1 : t + 1 - 1 = t
a : ℕ := n / (t + 1)
b : ℕ := n % (t + 1)
n2 : b < t + 1
hb : b = n % (t + 1)
hn : n > 0
hb' : b > 0
c : ℕ := t + 1 - b
n3 : c + b = t + 1
n1 : c * a + b * (a + 1) = n
hc2 : c - 1 + 1 = c
hb2 : b - 1 + 1 = b
⊢ a ^ 2 * (c * c) + 2 * (a * (a + 1) * b * c) + (a + 1) ^ 2 * (b * (b - 1) + b * 1) =
(c * a) ^ 2 + 2 * (c * a) * (b * (a + 1)) + (b * (a + 1)) ^ 2
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb'_2 | [122, 1] | [125, 40] | rw [← tn_turanNumb' t n] | t n : ℕ
⊢ 2 * turanNumb t n = n ^ 2 - turanNumb' t n | t n : ℕ
⊢ 2 * turanNumb t n = turanNumb' t n + 2 * turanNumb t n - turanNumb' t n | Please generate a tactic in lean4 to solve the state.
STATE:
t n : ℕ
⊢ 2 * turanNumb t n = n ^ 2 - turanNumb' t n
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.tn_turanNumb'_2 | [122, 1] | [125, 40] | exact (add_tsub_cancel_left _ _).symm | t n : ℕ
⊢ 2 * turanNumb t n = turanNumb' t n + 2 * turanNumb t n - turanNumb' t n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
t n : ℕ
⊢ 2 * turanNumb t n = turanNumb' t n + 2 * turanNumb t n - turanNumb' t n
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | have mc : c % (t + 1) = c := mod_eq_of_lt (succ_le_succ hc ) | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | have md : d % (t + 1) = d := mod_eq_of_lt (succ_le_succ hd) | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | rw [add_comm, add_comm _ d] at ht | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : (t + 1) * a + c = (t + 1) * b + d
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | have hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1) := add_mul_mod_self_left c (t + 1) a | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | have hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1) := add_mul_mod_self_left d (t + 1) b | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | rw [mc,ht] at hmtl | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (c + (t + 1) * a) % (t + 1) = c % (t + 1)
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | rw [md,hmtl] at hmtr | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b ∧ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : (d + (t + 1) * b) % (t + 1) = d % (t + 1)
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | refine' ⟨_, hmtr⟩ | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b ∧ c = d | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b ∧ c = d
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | rw [hmtr] at ht | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : d + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : c + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | rw [add_right_inj, mul_eq_mul_left_iff] at ht | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : d + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : a = b ∨ t + 1 = 0
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : d + (t + 1) * a = d + (t + 1) * b
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | cases ht with
| inl h => exact h
| inr h => contradiction | c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : a = b ∨ t + 1 = 0
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
ht : a = b ∨ t + 1 = 0
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
⊢ a = b
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | exact h | case inl
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
h : a = b
⊢ a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
h : a = b
⊢ a = b
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.mod_tplus1 | [138, 1] | [151, 27] | contradiction | case inr
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
h : t + 1 = 0
⊢ a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
c t d a b : ℕ
hc : c ≤ t
hd : d ≤ t
mc : c % (t + 1) = c
md : d % (t + 1) = d
hmtl : (d + (t + 1) * b) % (t + 1) = c
hmtr : c = d
h : t + 1 = 0
⊢ a = b
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | rw [smallParts] | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Finset.Nonempty (smallParts h) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Finset.Nonempty (smallParts h)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | have nem : ((range (t + 1)).image fun i => P i).Nonempty :=
(Nonempty.image_iff _).mpr nonempty_range_succ | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | set a : ℕ := min' ((range (t + 1)).image fun i => P i) nem with ha | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | have ain := min'_mem ((range (t + 1)).image fun i => P i) nem | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | rw [← ha, mem_image] at ain | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | obtain ⟨k, hk1, hk2⟩ := ain | t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | case intro.intro
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | use k | case intro.intro
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1))) | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ filter (fun i => P i = minP t P) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ Finset.Nonempty (filter (fun i => P i = minP t P) (range (t + 1)))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | rw [mem_filter] | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ filter (fun i => P i = minP t P) (range (t + 1)) | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ range (t + 1) ∧ P k = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ filter (fun i => P i = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | refine' ⟨hk1, _⟩ | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ range (t + 1) ∧ P k = minP t P | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ P k = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ k ∈ range (t + 1) ∧ P k = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | rw [ha] at hk2 | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ P k = minP t P | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = min' (image (fun i => P i) (range (t + 1))) nem
⊢ P k = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = a
⊢ P k = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.small_nonempty | [178, 1] | [187, 47] | exact hk2 | case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = min' (image (fun i => P i) (range (t + 1))) nem
⊢ P k = minP t P | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
t : ℕ
P : ℕ → ℕ
h : Balanced t P
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
k : ℕ
hk1 : k ∈ range (t + 1)
hk2 : P k = min' (image (fun i => P i) (range (t + 1))) nem
⊢ P k = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | unfold Balanced at h | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have nem : ((range (t + 1)).image fun i => P i).Nonempty :=
(Nonempty.image_iff _).mpr nonempty_range_succ | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | set a : ℕ := min' ((range (t + 1)).image fun i => P i) nem with ha | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | set b : ℕ := max' ((range (t + 1)).image fun i => P i) nem with hb | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | intro i hi | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
⊢ ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have ale : a ≤ P i := min'_le ((range (t + 1)).image fun i => P i) (P i) (mem_image_of_mem P hi) | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have leb : P i ≤ b := le_max' ((range (t + 1)).image fun i => P i) (P i) (mem_image_of_mem P hi) | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have ain := min'_mem ((range (t + 1)).image fun i => P i) nem | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | rw [← ha] at ain | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : min' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have bin := max'_mem ((range (t + 1)).image fun i => P i) nem | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : max' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | rw [← hb] at bin | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : max' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : max' (image (fun i => P i) (range (t + 1))) nem ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have blea : b ≤ a + 1 := by
rw [mem_image] at *
obtain ⟨k, hk, hak⟩ := ain; obtain ⟨l, hl, hbl⟩ := bin
rw [← hak, ← hbl]; exact h l hl k hk | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have ple := le_trans leb blea | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | by_contra h | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1 | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : ¬(P i = minP t P ∨ P i = minP t P + 1)
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
⊢ P i = minP t P ∨ P i = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | push_neg at h | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : ¬(P i = minP t P ∨ P i = minP t P + 1)
⊢ False | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : ¬(P i = minP t P ∨ P i = minP t P + 1)
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have h1 := lt_of_le_of_ne ale h.1.symm | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
⊢ False | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | have h2 := lt_of_le_of_ne ple h.2 | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
⊢ False | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | apply lt_irrefl (a+1) | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ False | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ a + 1 < a + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | exact lt_of_le_of_lt h1 h2 | t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ a + 1 < a + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h✝ : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
blea : b ≤ a + 1
ple : P i ≤ a + 1
h : P i ≠ minP t P ∧ P i ≠ minP t P + 1
h1 : a < P i
h2 : P i < a + 1
⊢ a + 1 < a + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | rw [mem_image] at * | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
⊢ b ≤ a + 1 | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
⊢ b ≤ a + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : a ∈ image (fun i => P i) (range (t + 1))
bin : b ∈ image (fun i => P i) (range (t + 1))
⊢ b ≤ a + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | obtain ⟨k, hk, hak⟩ := ain | t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
⊢ b ≤ a + 1 | case intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
⊢ b ≤ a + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
ain : ∃ a_1, a_1 ∈ range (t + 1) ∧ P a_1 = a
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
⊢ b ≤ a + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | obtain ⟨l, hl, hbl⟩ := bin | case intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
⊢ b ≤ a + 1 | case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ b ≤ a + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
bin : ∃ a, a ∈ range (t + 1) ∧ P a = b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
⊢ b ≤ a + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | rw [← hak, ← hbl] | case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ b ≤ a + 1 | case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ P l ≤ P k + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ b ≤ a + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.con_sum | [190, 1] | [211, 52] | exact h l hl k hk | case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ P l ≤ P k + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
t : ℕ
P : ℕ → ℕ
h : ∀ (i : ℕ), i ∈ range (t + 1) → ∀ (j : ℕ), j ∈ range (t + 1) → P i ≤ P j + 1
nem : Finset.Nonempty (image (fun i => P i) (range (t + 1)))
a : ℕ := min' (image (fun i => P i) (range (t + 1))) nem
ha : a = min' (image (fun i => P i) (range (t + 1))) nem
b : ℕ := max' (image (fun i => P i) (range (t + 1))) nem
hb : b = max' (image (fun i => P i) (range (t + 1))) nem
i : ℕ
hi : i ∈ range (t + 1)
ale : a ≤ P i
leb : P i ≤ b
k : ℕ
hk : k ∈ range (t + 1)
hak : P k = a
l : ℕ
hl : l ∈ range (t + 1)
hbl : P l = b
⊢ P l ≤ P k + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | have := con_sum h | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ largeParts h = filter (fun i => ¬P i = minP t P) (range (t + 1)) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ largeParts h = filter (fun i => ¬P i = minP t P) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ largeParts h = filter (fun i => ¬P i = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | unfold largeParts | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ largeParts h = filter (fun i => ¬P i = minP t P) (range (t + 1)) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ filter (fun i => P i = minP t P + 1) (range (t + 1)) = filter (fun i => ¬P i = minP t P) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ largeParts h = filter (fun i => ¬P i = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | ext a | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ filter (fun i => P i = minP t P + 1) (range (t + 1)) = filter (fun i => ¬P i = minP t P) (range (t + 1)) | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) ↔ a ∈ filter (fun i => ¬P i = minP t P) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ filter (fun i => P i = minP t P + 1) (range (t + 1)) = filter (fun i => ¬P i = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | rw [mem_filter, mem_filter] | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) ↔ a ∈ filter (fun i => ¬P i = minP t P) (range (t + 1)) | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 ↔ a ∈ range (t + 1) ∧ ¬P a = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) ↔ a ∈ filter (fun i => ¬P i = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | constructor | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 ↔ a ∈ range (t + 1) ∧ ¬P a = minP t P | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1) ∧ ¬P a = minP t P
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P → a ∈ range (t + 1) ∧ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 ↔ a ∈ range (t + 1) ∧ ¬P a = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | intro h' | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1) ∧ ¬P a = minP t P | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1) ∧ ¬P a = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | refine' ⟨h'.1, _⟩ | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ ¬P a = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | intro h2 | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ ¬P a = minP t P | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
h2 : P a = minP t P
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ ¬P a = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | rw [h2] at h' | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
h2 : P a = minP t P
⊢ False | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ minP t P = minP t P + 1
h2 : P a = minP t P
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ P a = minP t P + 1
h2 : P a = minP t P
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | exact succ_ne_self (minP t P) h'.2.symm | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ minP t P = minP t P + 1
h2 : P a = minP t P
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ minP t P = minP t P + 1
h2 : P a = minP t P
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | intro h' | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P → a ∈ range (t + 1) ∧ P a = minP t P + 1 | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ ¬P a = minP t P → a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | refine' ⟨h'.1, _⟩ | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | specialize this a h'.1 | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ P a = minP t P + 1 | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
this : P a = minP t P ∨ P a = minP t P + 1
⊢ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
⊢ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | cases this with
| inl h =>
exfalso; exact h'.2 h
| inr h => exact h | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
this : P a = minP t P ∨ P a = minP t P + 1
⊢ P a = minP t P + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
this : P a = minP t P ∨ P a = minP t P + 1
⊢ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | exfalso | case a.mpr.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P
⊢ P a = minP t P + 1 | case a.mpr.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P
⊢ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | exact h'.2 h | case a.mpr.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P
⊢ False
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.large_parts' | [214, 1] | [227, 23] | exact h | case a.mpr.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P + 1
⊢ P a = minP t P + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
h' : a ∈ range (t + 1) ∧ ¬P a = minP t P
h : P a = minP t P + 1
⊢ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_disjoint | [230, 1] | [234, 23] | convert disjoint_filter_filter_neg (range (t + 1)) (range (t + 1)) fun i => P i = minP t P | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Disjoint (smallParts h) (largeParts h) | case h.e'_5
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ largeParts h = filter (fun a => ¬P a = minP t P) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ Disjoint (smallParts h) (largeParts h)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_disjoint | [230, 1] | [234, 23] | exact large_parts' h | case h.e'_5
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ largeParts h = filter (fun a => ¬P a = minP t P) (range (t + 1)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ largeParts h = filter (fun a => ¬P a = minP t P) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | have := con_sum h | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ range (t + 1) = smallParts h ∪ largeParts h | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ range (t + 1) = smallParts h ∪ largeParts h | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ range (t + 1) = smallParts h ∪ largeParts h
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | ext a | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ range (t + 1) = smallParts h ∪ largeParts h | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ smallParts h ∪ largeParts h | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
⊢ range (t + 1) = smallParts h ∪ largeParts h
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | unfold smallParts | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ smallParts h ∪ largeParts h | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ largeParts h | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ smallParts h ∪ largeParts h
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | unfold largeParts | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ largeParts h | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ filter (fun i => P i = minP t P + 1) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ largeParts h
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | rw [mem_union] | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ filter (fun i => P i = minP t P + 1) (range (t + 1)) | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∪ filter (fun i => P i = minP t P + 1) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | constructor | case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) →
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1))
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) →
a ∈ range (t + 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ↔
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | intro ha | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) →
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) →
a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | rw [mem_filter, mem_filter] | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1))
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | specialize this a ha | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
this : P a = minP t P ∨ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
ha : a ∈ range (t + 1)
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | cases this with
| inl h =>
left; exact ⟨ha,h⟩
| inr h =>
right; exact ⟨ha, h⟩ | case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
this : P a = minP t P ∨ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp
t : ℕ
P : ℕ → ℕ
h : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
this : P a = minP t P ∨ P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | left | case a.mp.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | case a.mp.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | exact ⟨ha,h⟩ | case a.mp.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp.inl.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P
⊢ a ∈ range (t + 1) ∧ P a = minP t P
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | right | case a.mp.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 | case a.mp.inr.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | exact ⟨ha, h⟩ | case a.mp.inr.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mp.inr.h
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
a : ℕ
ha : a ∈ range (t + 1)
h : P a = minP t P + 1
⊢ a ∈ range (t + 1) ∧ P a = minP t P + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | rw [mem_filter, mem_filter] | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) →
a ∈ range (t + 1) | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ filter (fun i => P i = minP t P) (range (t + 1)) ∨ a ∈ filter (fun i => P i = minP t P + 1) (range (t + 1)) →
a ∈ range (t + 1)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | intro hr | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1) | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
hr : a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
⊢ a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1 → a ∈ range (t + 1)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | cases hr with
| inl h => exact h.1
| inr h => exact h.1 | case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
hr : a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
hr : a ∈ range (t + 1) ∧ P a = minP t P ∨ a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | exact h.1 | case a.mpr.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h : a ∈ range (t + 1) ∧ P a = minP t P
⊢ a ∈ range (t + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr.inl
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h : a ∈ range (t + 1) ∧ P a = minP t P
⊢ a ∈ range (t + 1)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_union | [237, 1] | [254, 25] | exact h.1 | case a.mpr.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a.mpr.inr
t : ℕ
P : ℕ → ℕ
h✝ : Balanced t P
this : ∀ (i : ℕ), i ∈ range (t + 1) → P i = minP t P ∨ P i = minP t P + 1
a : ℕ
h : a ∈ range (t + 1) ∧ P a = minP t P + 1
⊢ a ∈ range (t + 1)
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.parts_card_add | [257, 1] | [259, 83] | rw [← card_range (t + 1), parts_union h, card_disjoint_union (parts_disjoint h)] | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ card (smallParts h) + card (largeParts h) = t + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ card (smallParts h) + card (largeParts h) = t + 1
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.largeParts_card | [262, 1] | [266, 37] | have := Nat.add_le_add (card_pos.mpr (small_nonempty h)) (le_refl (card (largeParts h))) | t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ card (largeParts h) ≤ t | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : succ 0 + card (largeParts h) ≤ card (smallParts h) + card (largeParts h)
⊢ card (largeParts h) ≤ t | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
⊢ card (largeParts h) ≤ t
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.largeParts_card | [262, 1] | [266, 37] | rw [parts_card_add h,add_comm] at this | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : succ 0 + card (largeParts h) ≤ card (smallParts h) + card (largeParts h)
⊢ card (largeParts h) ≤ t | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : card (largeParts h) + succ 0 ≤ t + 1
⊢ card (largeParts h) ≤ t | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : succ 0 + card (largeParts h) ≤ card (smallParts h) + card (largeParts h)
⊢ card (largeParts h) ≤ t
TACTIC:
|
https://github.com/jt496/Turan_4.git | 329b6acff8f9b8f41609e3e5758ed80c61047eb5 | Turan4/Turanpartition.lean | Turanpartition.largeParts_card | [262, 1] | [266, 37] | apply le_of_add_le_add_right this | t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : card (largeParts h) + succ 0 ≤ t + 1
⊢ card (largeParts h) ≤ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
t : ℕ
P : ℕ → ℕ
h : Balanced t P
this : card (largeParts h) + succ 0 ≤ t + 1
⊢ card (largeParts h) ≤ t
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.