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/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.pos_part_mul_pos_part_main_formula | [53, 1] | [70, 50] | exact max_le h0 (mul_nonpos_of_nonneg_of_nonpos (sq_nonneg a) h0) | case inr.inl.h.h
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : b ≤ 0
⊢ max b (a ^ 2 * b) ≤ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.h.h
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : b ≤ 0
⊢ max b (a ^ 2 * b) ≤ 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.pos_part_mul_pos_part_main_formula | [53, 1] | [70, 50] | have h1 := mul_le_mul_of_nonneg_left (le_max_one_sq b) h | case inr.inr.refine_1
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
⊢ a * b ≤ max a (a * b ^ 2) | case inr.inr.refine_1
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ a * max 1 (b ^ 2)
⊢ a * b ≤ max a (a * b ^ 2) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.refine_1
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
⊢ a * b ≤ max a (a * b ^ 2)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.pos_part_mul_pos_part_main_formula | [53, 1] | [70, 50] | rwa [mul_max_of_nonneg _ _ h, mul_one] at h1 | case inr.inr.refine_1
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ a * max 1 (b ^ 2)
⊢ a * b ≤ max a (a * b ^ 2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.refine_1
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ a * max 1 (b ^ 2)
⊢ a * b ≤ max a (a * b ^ 2)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.pos_part_mul_pos_part_main_formula | [53, 1] | [70, 50] | have h1 := mul_le_mul_of_nonneg_right (le_max_one_sq a) h0 | case inr.inr.refine_2
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
⊢ a * b ≤ max b (a ^ 2 * b) | case inr.inr.refine_2
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ max 1 (a ^ 2) * b
⊢ a * b ≤ max b (a ^ 2 * b) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.refine_2
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
⊢ a * b ≤ max b (a ^ 2 * b)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.pos_part_mul_pos_part_main_formula | [53, 1] | [70, 50] | rwa [max_mul_of_nonneg _ _ h0, one_mul] at h1 | case inr.inr.refine_2
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ max 1 (a ^ 2) * b
⊢ a * b ≤ max b (a ^ 2 * b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.refine_2
R : Type u_1
inst✝ : LinearOrderedRing R
a b : R
h : 0 ≤ a
h0 : 0 ≤ b
h1 : a * b ≤ max 1 (a ^ 2) * b
⊢ a * b ≤ max b (a ^ 2 * b)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | rw [inf_pos_part, Pi_inf_mul_pos_part] | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) ((a✝ ⊓ b✝)⁺ * a✝¹⁺) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊓ b✝⁺ * a✝¹⁺) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) ((a✝ ⊓ b✝)⁺ * a✝¹⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | exact ofInf | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊓ b✝⁺ * a✝¹⁺) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊓ b✝⁺ * a✝¹⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | rw [sup_pos_part, Pi_sup_mul_pos_part] | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) ((a✝ ⊔ b✝)⁺ * a✝¹⁺) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊔ b✝⁺ * a✝¹⁺) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) ((a✝ ⊔ b✝)⁺ * a✝¹⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | exact ofSup | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊔ b✝⁺ * a✝¹⁺) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg✝ : MetaClosure (fun x => x ∈ S) g
a✝¹ : (i : I) → R i
hg : a✝¹ ∈ S
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺) →
MetaClosure (fun x => x ∈ S) (b✝⁺ * a✝¹⁺) → MetaClosure (fun x => x ∈ S) (a✝⁺ * a✝¹⁺ ⊔ b✝⁺ * a✝¹⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | rw [inf_pos_part, Pi_pos_part_mul_inf] | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * (a✝ ⊓ b✝)⁺) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊓ f⁺ * b✝⁺) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * (a✝ ⊓ b✝)⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | exact ofInf | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊓ f⁺ * b✝⁺) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊓ f⁺ * b✝⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | rw [sup_pos_part, Pi_pos_part_mul_sup] | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * (a✝ ⊔ b✝)⁺) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊔ f⁺ * b✝⁺) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * (a✝ ⊔ b✝)⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_closure_pos_part_mul_closure_pos_part_mem | [144, 1] | [153, 69] | exact ofSup | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊔ f⁺ * b✝⁺) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
a✝ b✝ : (i : I) → R i
x✝¹ : MetaClosure (fun x => x ∈ S) a✝
x✝ : MetaClosure (fun x => x ∈ S) b✝
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺) →
MetaClosure (fun x => x ∈ S) (f⁺ * b✝⁺) → MetaClosure (fun x => x ∈ S) (f⁺ * a✝⁺ ⊔ f⁺ * b✝⁺)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_mul_mem | [155, 1] | [164, 70] | rw [← posPart_sub_negPart f, sub_mul,
← posPart_sub_negPart g, mul_sub, mul_sub] | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
⊢ MetaClosure (fun x => x ∈ S) (f * g) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
⊢ MetaClosure (fun x => x ∈ S) (f * g)
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_mul_mem | [155, 1] | [164, 70] | let T := S.toAddSubgroup | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻))
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_mul_mem | [155, 1] | [164, 70] | have hf₀ : MetaClosure (λ x ↦ x ∈ S) (-f) := neg_mem T hf | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻))
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_mul_mem | [155, 1] | [164, 70] | have hg₀ : MetaClosure (λ x ↦ x ∈ S) (-g) := neg_mem T hg | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
hg₀ : MetaClosure (fun x => x ∈ S) (-g)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻))
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2012/A7/A7PiRing.lean | IMOSL.IMO2012A7.MetaClosure.Pi_mul_mem | [155, 1] | [164, 70] | apply sub_mem T <;> apply sub_mem T <;>
apply Pi_closure_pos_part_mul_closure_pos_part_mem <;> assumption | I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
hg₀ : MetaClosure (fun x => x ∈ S) (-g)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
I : Type u_2
R : I → Type u_1
inst✝ : (i : I) → LinearOrderedRing (R i)
S : Subring ((i : I) → R i)
f g : (i : I) → R i
hf : MetaClosure (fun x => x ∈ S) f
hg : MetaClosure (fun x => x ∈ S) g
T : AddSubgroup ((i : I) → R i) := S.toAddSubgroup
hf₀ : MetaClosure (fun x => x ∈ S) (-f)
hg₀ : MetaClosure (fun x => x ∈ S) (-g)
⊢ MetaClosure (fun x => x ∈ S) (f⁺ * g⁺ - f⁺ * g⁻ - (f⁻ * g⁺ - f⁻ * g⁻))
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | replace h0 (k : ℕ) : (k.succ : F) / a k.succ ≤ a k + k / a k := by
rw [add_div' _ _ _ (h k).ne.symm, div_le_div_iff (h _) (h k), ← sq]
exact (div_le_iff' <| add_pos_of_pos_of_nonneg
(pow_pos (h k) 2) k.cast_nonneg).mp (h0 k) | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a | Please generate a tactic in lean4 to solve the state.
STATE:
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | refine Nat.le_induction ?_ ?_ | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑2 ≤ (range 2).sum a
case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a → ↑(n + 1) ≤ (range (n + 1)).sum a | Please generate a tactic in lean4 to solve the state.
STATE:
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [add_div' _ _ _ (h k).ne.symm, div_le_div_iff (h _) (h k), ← sq] | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
k : ℕ
⊢ ↑k.succ / a k.succ ≤ a k + ↑k / a k | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
k : ℕ
⊢ ↑k.succ * a k ≤ (a k ^ 2 + ↑k) * a k.succ | Please generate a tactic in lean4 to solve the state.
STATE:
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
k : ℕ
⊢ ↑k.succ / a k.succ ≤ a k + ↑k / a k
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | exact (div_le_iff' <| add_pos_of_pos_of_nonneg
(pow_pos (h k) 2) k.cast_nonneg).mp (h0 k) | F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
k : ℕ
⊢ ↑k.succ * a k ≤ (a k ^ 2 + ↑k) * a k.succ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ * a k / (a k ^ 2 + ↑k) ≤ a k.succ
k : ℕ
⊢ ↑k.succ * a k ≤ (a k ^ 2 + ↑k) * a k.succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [Nat.cast_two, sum_range_succ, sum_range_one] | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑2 ≤ (range 2).sum a | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ 2 ≤ a 0 + a 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑2 ≤ (range 2).sum a
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | specialize h0 0 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ 2 ≤ a 0 + a 1 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ↑(Nat.succ 0) / a (Nat.succ 0) ≤ a 0 + ↑0 / a 0
⊢ 2 ≤ a 0 + a 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ 2 ≤ a 0 + a 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [Nat.cast_one, Nat.cast_zero, zero_div, add_zero] at h0 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ↑(Nat.succ 0) / a (Nat.succ 0) ≤ a 0 + ↑0 / a 0
⊢ 2 ≤ a 0 + a 1 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ a 0 + a 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ↑(Nat.succ 0) / a (Nat.succ 0) ≤ a 0 + ↑0 / a 0
⊢ 2 ≤ a 0 + a 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | apply (add_le_add_right h0 _).trans' | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ a 0 + a 1 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ 1 / a (Nat.succ 0) + a 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ a 0 + a 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [div_add' _ _ _ (h 1).ne.symm, le_div_iff (h 1), ← sq] | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ 1 / a (Nat.succ 0) + a 1 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 ≤ 1 / a (Nat.succ 0) + a 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | have h1 := two_mul_le_add_sq 1 (a 1) | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
h1 : 2 * 1 * a 1 ≤ 1 ^ 2 + a 1 ^ 2
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rwa [mul_one, one_pow] at h1 | case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
h1 : 2 * 1 * a 1 ≤ 1 ^ 2 + a 1 ^ 2
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : 1 / a (Nat.succ 0) ≤ a 0
h1 : 2 * 1 * a 1 ≤ 1 ^ 2 + a 1 ^ 2
⊢ 2 * a 1 ≤ 1 + a 1 ^ 2
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | intro n h1 h2 | case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a → ↑(n + 1) ≤ (range (n + 1)).sum a | case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑(n + 1) ≤ (range (n + 1)).sum a | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ∀ (n : ℕ), 2 ≤ n → ↑n ≤ (range n).sum a → ↑(n + 1) ≤ (range (n + 1)).sum a
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [sum_range_succ, Nat.cast_succ] | case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑(n + 1) ≤ (range (n + 1)).sum a | case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑(n + 1) ≤ (range (n + 1)).sum a
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rcases le_total 1 (a n) with h3 | h3 | case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n | case refine_2.inl
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : 1 ≤ a n
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n
case refine_2.inr
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | refine le_trans ?_ (add_le_add_right (?_ : (n : F) / a n ≤ _) _) | case refine_2.inr
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ↑n / a n + a n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [div_add' _ _ _ (h n).ne.symm, le_div_iff (h n), add_one_mul (α := F),
← sub_le_iff_le_add, add_sub_assoc, ← mul_one_sub,
← le_sub_iff_add_le', ← mul_one_sub, ← sub_nonneg, ← sub_mul] | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ↑n / a n + a n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 0 ≤ (↑n - a n) * (1 - a n)
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n + 1 ≤ ↑n / a n + a n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | refine mul_nonneg (sub_nonneg.mpr (h3.trans ?_)) (sub_nonneg.mpr h3) | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 0 ≤ (↑n - a n) * (1 - a n)
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ ↑n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 0 ≤ (↑n - a n) * (1 - a n)
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [Nat.one_le_cast] | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ ↑n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ ↑n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | exact one_le_two.trans h1 | case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_1
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ 1 ≤ n
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | clear h1 h2 h3 | case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : a n ≤ 1
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | induction' n with n n_ih | case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x | case refine_2.inr.refine_2.zero
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑0 / a 0 ≤ ∑ x ∈ range 0, a x
case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_2
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
⊢ ↑n / a n ≤ ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [Nat.cast_zero, sum_range_zero, zero_div] | case refine_2.inr.refine_2.zero
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑0 / a 0 ≤ ∑ x ∈ range 0, a x
case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x | case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_2.zero
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
⊢ ↑0 / a 0 ≤ ∑ x ∈ range 0, a x
case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | rw [sum_range_succ, add_comm _ (a n)] | case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x | case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ a n + ∑ x ∈ range n, a x | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ ∑ x ∈ range (n + 1), a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | refine (h0 n).trans (add_le_add_left n_ih (a n)) | case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ a n + ∑ x ∈ range n, a x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inr.refine_2.succ
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
n_ih : ↑n / a n ≤ ∑ x ∈ range n, a x
⊢ ↑(n + 1) / a (n + 1) ≤ a n + ∑ x ∈ range n, a x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2015/A1/A1.lean | IMOSL.IMO2015A1.final_solution | [33, 1] | [65, 53] | exact add_le_add h2 h3 | case refine_2.inl
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : 1 ≤ a n
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.inl
F : Type u_1
inst✝ : LinearOrderedField F
a : ℕ → F
h : ∀ (k : ℕ), 0 < a k
h0 : ∀ (k : ℕ), ↑k.succ / a k.succ ≤ a k + ↑k / a k
n : ℕ
h1 : 2 ≤ n
h2 : ↑n ≤ (range n).sum a
h3 : 1 ≤ a n
⊢ ↑n + 1 ≤ ∑ x ∈ range n, a x + a n
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | obtain ⟨n, h0, h1⟩ := h0 (b + (f 0 - f b).natAbs + 1) | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b : ℕ
⊢ f b = f 0 | case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b : ℕ
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | specialize h n b | case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
⊢ f b = f 0 | case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | rw [Nat.succ_le_iff, lt_iff_exists_add] at h0 | case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0 | case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : ∃ c > 0, n = b + (f 0 - f b).natAbs + c
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : b + (f 0 - f b).natAbs + 1 ≤ n
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | rcases h0 with ⟨C, h0, rfl⟩ | case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : ∃ c > 0, n = b + (f 0 - f b).natAbs + c
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0 | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : ↑(b + (f 0 - f b).natAbs + C) - ↑b ∣ f (b + (f 0 - f b).natAbs + C) - f b
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b n : ℕ
h0 : ∃ c > 0, n = b + (f 0 - f b).natAbs + c
h1 : f n = f 0
h : ↑n - ↑b ∣ f n - f b
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | rw [h1, add_assoc, Nat.cast_add, add_sub_cancel_left, Int.natCast_dvd] at h | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : ↑(b + (f 0 - f b).natAbs + C) - ↑b ∣ f (b + (f 0 - f b).natAbs + C) - f b
⊢ f b = f 0 | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : ↑(b + (f 0 - f b).natAbs + C) - ↑b ∣ f (b + (f 0 - f b).natAbs + C) - f b
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | have h2 := Nat.eq_zero_of_dvd_of_lt h (Nat.lt_add_of_pos_right h0) | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
⊢ f b = f 0 | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
h2 : (f 0 - f b).natAbs = 0
⊢ f b = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_infinite_map_eq_map_zero | [31, 1] | [40, 58] | rwa [Int.natAbs_eq_zero, sub_eq_zero, eq_comm] at h2 | case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
h2 : (f 0 - f b).natAbs = 0
⊢ f b = f 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro
f : ℕ → ℤ
h0✝ : ∀ (k : ℕ), ∃ n, k ≤ n ∧ f n = f 0
b C : ℕ
h0 : C > 0
h1 : f (b + (f 0 - f b).natAbs + C) = f 0
h : (f 0 - f b).natAbs + C ∣ (f 0 - f b).natAbs
h2 : (f 0 - f b).natAbs = 0
⊢ f b = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | have h1 : f 0 ≠ 0 := λ h1 ↦ by
obtain ⟨p, h2, h3⟩ := K.exists_infinite_primes
exact h2.not_lt (h0 p h3 ⟨0, 0, h1⟩) | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
⊢ ∃ C, f = fun x => C | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
⊢ ∃ C, f = fun x => C | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
⊢ ∃ C, f = fun x => C
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | refine const_of_infinite_map_eq_map_zero h
λ k ↦ ⟨(f 0).natAbs * (4 * K.factorial) * k, ?_, ?_⟩ | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
⊢ ∃ C, f = fun x => C | case refine_1
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ k ≤ (f 0).natAbs * (4 * K.factorial) * k
case refine_2
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
⊢ ∃ C, f = fun x => C
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | obtain ⟨p, h2, h3⟩ := K.exists_infinite_primes | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 = 0
⊢ False | case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 = 0
p : ℕ
h2 : K ≤ p
h3 : p.Prime
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 = 0
⊢ False
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | exact h2.not_lt (h0 p h3 ⟨0, 0, h1⟩) | case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 = 0
p : ℕ
h2 : K ≤ p
h3 : p.Prime
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 = 0
p : ℕ
h2 : K ≤ p
h3 : p.Prime
⊢ False
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | exact Nat.le_mul_of_pos_left _ <| Nat.mul_pos (Int.natAbs_pos.mpr h1)
(Nat.mul_pos (Nat.succ_pos 3) K.factorial_pos) | case refine_1
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ k ≤ (f 0).natAbs * (4 * K.factorial) * k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ k ≤ (f 0).natAbs * (4 * K.factorial) * k
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | specialize h ((f 0).natAbs * (4 * K.factorial) * k) 0 | case refine_2
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial) * k) - ↑0 ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [Nat.cast_zero, Int.sub_zero, Nat.cast_mul] at h | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial) * k) - ↑0 ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) * ↑k ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial) * k) - ↑0 ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | apply (dvd_mul_right _ _).trans at h | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) * ↑k ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) * ↑k ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [Nat.cast_mul, ← abs_dvd, Int.natCast_natAbs,
abs_mul, abs_abs, ← abs_mul, abs_dvd] at h | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : ↑((f 0).natAbs * (4 * K.factorial)) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | obtain ⟨m, h2⟩ := dvd_sub_self_right.mp (dvd_of_mul_right_dvd h) | case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [h2, ← mul_sub_one, mul_dvd_mul_iff_left h1, Int.natCast_dvd] at h | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
h : f 0 * ↑(4 * K.factorial) ∣ f ((f 0).natAbs * (4 * K.factorial) * k) - f 0
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [h2, mul_right_eq_self₀, or_iff_left h1] | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ f ((f 0).natAbs * (4 * K.factorial) * k) = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | clear h1 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
h1 : f 0 ≠ 0
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | by_cases h1 : m.natAbs = 1 | case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1 | case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m.natAbs = 1
⊢ m = 1
case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ¬m.natAbs = 1
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [Int.natAbs_eq_iff, Nat.cast_one] at h1 | case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m.natAbs = 1
⊢ m = 1 | case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m = 1 ∨ m = -1
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m.natAbs = 1
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | exact h1.resolve_right λ h1 ↦ absurd ((dvd_mul_right _ _).trans (h1 ▸ h))
(Nat.not_dvd_of_pos_of_lt (Nat.succ_pos 1) (Nat.le_succ 3)) | case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m = 1 ∨ m = -1
⊢ m = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : m = 1 ∨ m = -1
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | apply Nat.exists_prime_and_dvd at h1 | case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ¬m.natAbs = 1
⊢ m = 1 | case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ∃ p, p.Prime ∧ p ∣ m.natAbs
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ¬m.natAbs = 1
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rcases h1 with ⟨p, h1, h3⟩ | case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ∃ p, p.Prime ∧ p ∣ m.natAbs
⊢ m = 1 | case neg.intro.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
h1 : ∃ p, p.Prime ∧ p ∣ m.natAbs
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | specialize h0 p h1 ⟨(f 0).natAbs * (4 * Nat.factorial K) * k,
h2 ▸ dvd_mul_of_dvd_right (Int.natCast_dvd.mpr h3) _⟩ | case neg.intro.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
⊢ m = 1 | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro
f : ℕ → ℤ
K : ℕ
h0 : ∀ (p : ℕ), p.Prime → (∃ c, ↑p ∣ f c) → p < K
k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | replace h := (Nat.dvd_factorial h1.pos h0.le).trans (dvd_of_mul_left_dvd h) | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
⊢ m = 1 | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
h : p ∣ (m - 1).natAbs
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h : 4 * K.factorial ∣ (m - 1).natAbs
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | rw [← Int.natCast_dvd] at h h3 | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
h : p ∣ (m - 1).natAbs
⊢ m = 1 | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : ↑p ∣ m
h0 : p < K
h : ↑p ∣ m - 1
⊢ m = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : p ∣ m.natAbs
h0 : p < K
h : p ∣ (m - 1).natAbs
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.const_of_finite_prime_divisor | [42, 1] | [74, 61] | exact absurd (Int.natCast_dvd.mp <|
(Int.dvd_iff_dvd_of_dvd_sub h).mp h3) h1.not_dvd_one | case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : ↑p ∣ m
h0 : p < K
h : ↑p ∣ m - 1
⊢ m = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.intro.intro
f : ℕ → ℤ
K k : ℕ
m : ℤ
h2 : f ((f 0).natAbs * (4 * K.factorial) * k) = f 0 * m
p : ℕ
h1 : p.Prime
h3 : ↑p ∣ m
h0 : p < K
h : ↑p ∣ m - 1
⊢ m = 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.final_solution | [79, 1] | [85, 68] | refine by_contra λ h1 ↦ absurd h0 (not_forall.mpr ⟨f 0, ?_⟩) | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
⊢ ∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ¬∃ b, f b ≠ f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
⊢ ∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.final_solution | [79, 1] | [85, 68] | rw [← not_forall, not_not] | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ¬∃ b, f b ≠ f 0 | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∀ (x : ℕ), f x = f 0 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ¬∃ b, f b ≠ f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.final_solution | [79, 1] | [85, 68] | suffices ∃ C, f = λ _ ↦ C from this.elim λ C this ↦ this ▸ λ x ↦ rfl | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∀ (x : ℕ), f x = f 0 | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∃ C, f = fun x => C | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∀ (x : ℕ), f x = f 0
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2009/N3/N3.lean | IMOSL.IMO2009N3.final_solution | [79, 1] | [85, 68] | exact const_of_finite_prime_divisor h (K := K)
λ p h2 h3 ↦ lt_of_not_le λ h4 ↦ not_exists.mp h1 p ⟨h4, h2, h3⟩ | f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∃ C, f = fun x => C | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℤ
h : ∀ (a b : ℕ), ↑a - ↑b ∣ f a - f b
h0 : ∀ (C : ℤ), ∃ b, f b ≠ C
K : ℕ
h1 : ¬∃ p, K ≤ p ∧ p.Prime ∧ ∃ c, ↑p ∣ f c
⊢ ∃ C, f = fun x => C
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iter_four_eq | [61, 1] | [64, 52] | rw [f.iterate_succ_apply, h, ← h n, ← f.iterate_succ_apply'] | f : ℕ → ℕ
h : good f
n : ℕ
⊢ f^[4] (n + 1) = f^[4] n + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
n : ℕ
⊢ f^[4] (n + 1) = f^[4] n + 1
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iter_four_eq | [61, 1] | [64, 52] | rw [Nat.add_succ, h0, h1] | f : ℕ → ℕ
h : good f
h0 : ∀ (n : ℕ), f^[4] (n + 1) = f^[4] n + 1
n : ℕ
h1 : f^[4] n = f^[4] 0 + n
⊢ f^[4] n.succ = f^[4] 0 + n.succ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
h0 : ∀ (n : ℕ), f^[4] (n + 1) = f^[4] n + 1
n : ℕ
h1 : f^[4] n = f^[4] 0 + n
⊢ f^[4] n.succ = f^[4] 0 + n.succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.good_injective | [66, 1] | [68, 76] | rwa [iter_four_eq h, iter_four_eq h n, add_right_inj] at h0 | f : ℕ → ℕ
h : good f
m n : ℕ
h0 : f^[4] m = f^[4] n
⊢ m = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
m n : ℕ
h0 : f^[4] m = f^[4] n
⊢ m = n
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | intro x h0 | f : ℕ → ℕ
h : good f
⊢ (finChainFnOfgood h).iterRangeCompl 3 ⊆ {0, (f 0).succ} ∪ image Nat.succ (finChainFnOfgood h).rangeCompl | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x ∈ {0, (f 0).succ} ∪ image Nat.succ (finChainFnOfgood h).rangeCompl | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
⊢ (finChainFnOfgood h).iterRangeCompl 3 ⊆ {0, (f 0).succ} ∪ image Nat.succ (finChainFnOfgood h).rangeCompl
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | rw [mem_union, mem_image, mem_insert, mem_singleton, or_assoc] | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x ∈ {0, (f 0).succ} ∪ image Nat.succ (finChainFnOfgood h).rangeCompl | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x = 0 ∨ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x ∈ {0, (f 0).succ} ∪ image Nat.succ (finChainFnOfgood h).rangeCompl
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | refine x.eq_zero_or_eq_succ_pred.imp id λ h1 ↦ ?_ | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x = 0 ∨ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : x = x.pred.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ x = 0 ∨ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | generalize x.pred = c at h1 | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : x = x.pred.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
c : ℕ
h1 : x = c.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : x = x.pred.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | subst h1 | f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
c : ℕ
h1 : x = c.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x | f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ c.succ = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = c.succ | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
x : ℕ
h0 : x ∈ (finChainFnOfgood h).iterRangeCompl 3
c : ℕ
h1 : x = c.succ
⊢ x = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = x
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | refine (em <| c ∈ Set.range f).imp (λ h1 ↦ ?_) (λ h1 ↦ ⟨c, ?_, rfl⟩) | f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ c.succ = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = c.succ | case refine_1
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∈ Set.range f
⊢ c.succ = (f 0).succ
case refine_2
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∉ Set.range f
⊢ c ∈ (finChainFnOfgood h).rangeCompl | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ c.succ = (f 0).succ ∨ ∃ a ∈ (finChainFnOfgood h).rangeCompl, a.succ = c.succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | rcases h1 with ⟨d, rfl⟩ | case refine_1
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∈ Set.range f
⊢ c.succ = (f 0).succ | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ (f d).succ = (f 0).succ | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∈ Set.range f
⊢ c.succ = (f 0).succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | refine d.eq_zero_or_eq_succ_pred.elim (λ h2 ↦ h2 ▸ rfl) (λ h2 ↦ ?_) | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ (f d).succ = (f 0).succ | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
⊢ (f d).succ = (f 0).succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | rw [(finChainFnOfgood h).mem_iterRangeCompl_iff] at h0 | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | refine absurd ⟨d.pred, ?_⟩ h0 | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ f^[3] d.pred = (f d).succ | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ (f d).succ = (f 0).succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | rw [h, ← d.pred.succ_eq_add_one, ← h2] | case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ f^[3] d.pred = (f d).succ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1.intro
f : ℕ → ℕ
h : good f
d : ℕ
h0 : (f d).succ ∉ Set.range f^[3]
h2 : d = d.pred.succ
⊢ f^[3] d.pred = (f d).succ
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iterRangeCompl_three_subset | [78, 1] | [91, 50] | rwa [(finChainFnOfgood h).mem_rangeCompl_iff] | case refine_2
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∉ Set.range f
⊢ c ∈ (finChainFnOfgood h).rangeCompl | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
f : ℕ → ℕ
h : good f
c : ℕ
h0 : c.succ ∈ (finChainFnOfgood h).iterRangeCompl 3
h1 : c ∉ Set.range f
⊢ c ∈ (finChainFnOfgood h).rangeCompl
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | have h0 := (card_le_card <| iterRangeCompl_three_subset h).trans <|
(card_union_le _ _).trans <| Nat.add_le_add
(card_pair (f 0).succ_ne_zero.symm).le card_image_le | f : ℕ → ℕ
h : good f
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | f : ℕ → ℕ
h : good f
h0 : ((finChainFnOfgood h).iterRangeCompl 3).card ≤ 2 + (finChainFnOfgood h).rangeCompl.card
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | rw [(finChainFnOfgood h).iterRangeCompl_card, Nat.succ_mul,
Nat.add_le_add_iff_right, mul_comm, ← Nat.le_div_iff_mul_le (Nat.succ_pos 1)] at h0 | f : ℕ → ℕ
h : good f
h0 : ((finChainFnOfgood h).iterRangeCompl 3).card ≤ 2 + (finChainFnOfgood h).rangeCompl.card
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | f : ℕ → ℕ
h : good f
h0 : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
h0 : ((finChainFnOfgood h).iterRangeCompl 3).card ≤ 2 + (finChainFnOfgood h).rangeCompl.card
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | refine h0.eq_or_lt.elim card_eq_one.mp (λ h0 ↦ ?_) | f : ℕ → ℕ
h : good f
h0 : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : (finChainFnOfgood h).rangeCompl.card < 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
h0 : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | rw [Nat.lt_one_iff, card_eq_zero, ← (finChainFnOfgood h).surjective_iff] at h0 | f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : (finChainFnOfgood h).rangeCompl.card < 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : Function.Surjective f
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : (finChainFnOfgood h).rangeCompl.card < 2 / Nat.succ 1
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | obtain ⟨a, h0⟩ := h0.iterate 3 0 | f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : Function.Surjective f
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | case intro
f : ℕ → ℕ
h : good f
h0✝¹ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0✝ : Function.Surjective f
a : ℕ
h0 : f^[3] a = 0
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
h0✝ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0 : Function.Surjective f
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.exists_rangeCompl_eq_singleton | [93, 1] | [103, 61] | exact absurd ((h a).symm.trans h0) (f a.succ).succ_ne_zero | case intro
f : ℕ → ℕ
h : good f
h0✝¹ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0✝ : Function.Surjective f
a : ℕ
h0 : f^[3] a = 0
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
f : ℕ → ℕ
h : good f
h0✝¹ : (finChainFnOfgood h).rangeCompl.card ≤ 2 / Nat.succ 1
h0✝ : Function.Surjective f
a : ℕ
h0 : f^[3] a = 0
⊢ ∃ a, (finChainFnOfgood h).rangeCompl = {a}
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iter_four_zero_eq_four | [105, 1] | [114, 60] | obtain ⟨a, h0⟩ := exists_rangeCompl_eq_singleton h | f : ℕ → ℕ
h : good f
⊢ f^[4] 0 = 4 | case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ f^[4] 0 = 4 | Please generate a tactic in lean4 to solve the state.
STATE:
f : ℕ → ℕ
h : good f
⊢ f^[4] 0 = 4
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iter_four_zero_eq_four | [105, 1] | [114, 60] | suffices (finChainFnOfgood h).iterRangeCompl 4 = range (f^[4] 0) by
rw [← card_range (f^[4] 0), ← this,
(finChainFnOfgood h).iterRangeCompl_card, h0, card_singleton] | case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ f^[4] 0 = 4 | case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ (finChainFnOfgood h).iterRangeCompl 4 = range (f^[4] 0) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ f^[4] 0 = 4
TACTIC:
|
https://github.com/mortarsanjaya/IMOSLLean4.git | be127d301e366822fbeeeda49d9fd5b998fb4eb5 | IMOSLLean4/IMO2013/A5/A5.lean | IMOSL.IMO2013A5.iter_four_zero_eq_four | [105, 1] | [114, 60] | ext n | case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ (finChainFnOfgood h).iterRangeCompl 4 = range (f^[4] 0) | case intro.a
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
n : ℕ
⊢ n ∈ (finChainFnOfgood h).iterRangeCompl 4 ↔ n ∈ range (f^[4] 0) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
f : ℕ → ℕ
h : good f
a : ℕ
h0 : (finChainFnOfgood h).rangeCompl = {a}
⊢ (finChainFnOfgood h).iterRangeCompl 4 = range (f^[4] 0)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.