ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddCon.list_sum
File: Mathlib/GroupTheory/Congruence/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝ : Monoid M
c : Con M
l : List ι
f g : ι → M
h : ∀ x ∈ l, c (f x) (g x)
⊢ c (List.map f l).prod (List.map g l).prod
state_after: no goals
tactic: induction l with
  | nil =>
    simpa only [List.map_nil, List.prod_nil] using c.refl 1
  | cons x xs ih =>
    rw [List.map_cons, List.map_cons, List.prod_cons, List.prod_cons]
    exact c.mul (h _ <| .head _) <| ih fun k hk ↦ h _ (.tail _ hk)
Theorem: Finset.Icc_subset_Iic_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Icc a b ⊆ Iic b
state_after: no goals
tactic: simpa [← coe_subset] using Set.Icc_subset_Iic_self
Theorem: segment_eq_image_lineMap
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
⊢ [x-[𝕜]y] = ⇑(AffineMap.lineMap x y) '' Icc 0 1
state_after: case h.e'_3.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a✝¹ : 𝕜
a✝ : a✝¹ ∈ Icc 0 1
⊢ (AffineMap.lineMap x y) a✝¹ = (1 - a✝¹) • x + a✝¹ • y
tactic: convert segment_eq_image 𝕜 x y using 2
state_before: case h.e'_3.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a✝¹ : 𝕜
a✝ : a✝¹ ∈ Icc 0 1
⊢ (AffineMap.lineMap x y) a✝¹ = (1 - a✝¹) • x + a✝¹ • y
state_after: no goals
tactic: exact AffineMap.lineMap_apply_module _ _ _
Theorem: Units.map_neg_one
File: Mathlib/Algebra/Ring/Units.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝³ : Ring α
a b : α
F : Type u_1
inst✝² : Ring β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
f : F
⊢ (map ↑f) (-1) = -1
state_after: no goals
tactic: simp only [Units.map_neg, map_one]
Theorem: Nat.range_rec
File: Mathlib/Data/Nat/Set.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
⊢ (range fun n => rec x f n) = {x} ∪ range fun n => rec (f 0 x) (f ∘ succ) n
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = ((fun n => rec x f n) ∘ succ) x✝
tactic: convert (range_of_succ (fun n => Nat.rec x f n : ℕ → α)).symm using 4
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = ((fun n => rec x f n) ∘ succ) x✝
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = f x✝ (rec x f x✝)
tactic: dsimp
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
x✝ : ℕ
⊢ rec (f 0 x) (f ∘ succ) x✝ = f x✝ (rec x f x✝)
state_after: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
⊢ rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
tactic: rename_i n
state_before: case h.e'_3.h.e'_4.h.e'_3.h
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
⊢ rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
state_after: case h.e'_3.h.e'_4.h.e'_3.h.zero
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
⊢ rec (f 0 x) (f ∘ succ) 0 = f 0 (rec x f 0)

case h.e'_3.h.e'_4.h.e'_3.h.succ
α✝ : Type u_1
α : Type u_2
x : α
f : ℕ → α → α
n : ℕ
ihn : rec (f 0 x) (f ∘ succ) n = f n (rec x f n)
⊢ rec (f 0 x) (f ∘ succ) (n + 1) = f (n + 1) (rec x f (n + 1))
tactic: induction' n with n ihn
Theorem: smul_le_iff_le_one_left
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁷ : Monoid α
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : MulAction α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : SMulPosMono α β
inst✝ : SMulPosReflectLE α β
hb : 0 < b
⊢ a • b ≤ b ↔ a • b ≤ 1 • b
state_after: no goals
tactic: rw [one_smul]
Theorem: antivaryOn_neg_right
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ AntivaryOn f g⁻¹ s ↔ MonovaryOn f g s
state_after: no goals
tactic: simpa [MonovaryOn, AntivaryOn] using forall₂_swap
Theorem: tendsto_norm_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ Tendsto (fun a => ‖a‖) (𝓝 1) (𝓝 0)
state_after: no goals
tactic: simpa using tendsto_norm_div_self (1 : E)
Theorem: Filter.pure_seq_eq_map
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
g : α → β
f : Filter α
⊢ (pure g).seq f = map g f
state_after: case refine_1
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
g : α → β
f : Filter α
s : Set α
hs : s ∈ f
⊢ g '' s ∈ (pure g).seq f

case refine_2
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
g : α → β
f : Filter α
s : Set (α → β)
hs : s ∈ pure g
t : Set α
ht : t ∈ f
⊢ s.seq t ∈ map g f
tactic: refine le_antisymm (le_map fun s hs => ?_) (le_seq fun s hs t ht => ?_)
Theorem: Metric.equicontinuousAt_iff_pair
File: Mathlib/Topology/MetricSpace/Equicontinuity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι✝ : Type u_3
inst✝¹ : PseudoMetricSpace α
ι : Type u_4
inst✝ : TopologicalSpace β
F : ι → β → α
x₀ : β
⊢ EquicontinuousAt F x₀ ↔ ∀ ε > 0, ∃ U ∈ 𝓝 x₀, ∀ x ∈ U, ∀ x' ∈ U, ∀ (i : ι), dist (F i x) (F i x') < ε
state_after: α : Type u_1
β : Type u_2
ι✝ : Type u_3
inst✝¹ : PseudoMetricSpace α
ι : Type u_4
inst✝ : TopologicalSpace β
F : ι → β → α
x₀ : β
⊢ (∀ U ∈ 𝓤 α, ∃ V ∈ 𝓝 x₀, ∀ x ∈ V, ∀ y ∈ V, ∀ (i : ι), (F i x, F i y) ∈ U) ↔
    ∀ ε > 0, ∃ U ∈ 𝓝 x₀, ∀ x ∈ U, ∀ x' ∈ U, ∀ (i : ι), dist (F i x) (F i x') < ε
tactic: rw [equicontinuousAt_iff_pair]
state_before: α : Type u_1
β : Type u_2
ι✝ : Type u_3
inst✝¹ : PseudoMetricSpace α
ι : Type u_4
inst✝ : TopologicalSpace β
F : ι → β → α
x₀ : β
⊢ (∀ U ∈ 𝓤 α, ∃ V ∈ 𝓝 x₀, ∀ x ∈ V, ∀ y ∈ V, ∀ (i : ι), (F i x, F i y) ∈ U) ↔
    ∀ ε > 0, ∃ U ∈ 𝓝 x₀, ∀ x ∈ U, ∀ x' ∈ U, ∀ (i : ι), dist (F i x) (F i x') < ε
state_after: case mp
α : Type u_1
β : Type u_2
ι✝ : Type u_3
inst✝¹ : PseudoMetricSpace α
ι : Type u_4
inst✝ : TopologicalSpace β
F : ι → β → α
x₀ : β
H : ∀ U ∈ 𝓤 α, ∃ V ∈ 𝓝 x₀, ∀ x ∈ V, ∀ y ∈ V, ∀ (i : ι), (F i x, F i y) ∈ U
⊢ ∀ ε > 0, ∃ U ∈ 𝓝 x₀, ∀ x ∈ U, ∀ x' ∈ U, ∀ (i : ι), dist (F i x) (F i x') < ε

case mpr
α : Type u_1
β : Type u_2
ι✝ : Type u_3
inst✝¹ : PseudoMetricSpace α
ι : Type u_4
inst✝ : TopologicalSpace β
F : ι → β → α
x₀ : β
H : ∀ ε > 0, ∃ U ∈ 𝓝 x₀, ∀ x ∈ U, ∀ x' ∈ U, ∀ (i : ι), dist (F i x) (F i x') < ε
⊢ ∀ U ∈ 𝓤 α, ∃ V ∈ 𝓝 x₀, ∀ x ∈ V, ∀ y ∈ V, ∀ (i : ι), (F i x, F i y) ∈ U
tactic: constructor <;> intro H
Theorem: AddSubgroupClass.subtype_comp_inclusion
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
⊢ (↑K).comp (inclusion hH) = ↑H
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
x✝ : ↥H
⊢ ((↑K).comp (inclusion hH)) x✝ = ↑H x✝
tactic: ext
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
x✝ : ↥H
⊢ ((↑K).comp (inclusion hH)) x✝ = ↑H x✝
state_after: no goals
tactic: simp only [MonoidHom.comp_apply, coeSubtype, coe_inclusion]
Theorem: PiNat.min_firstDiff_le
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
⊢ min (firstDiff x y) (firstDiff y z) ≤ firstDiff x z
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < min (firstDiff x y) (firstDiff y z)
⊢ False
tactic: by_contra! H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < min (firstDiff x y) (firstDiff y z)
⊢ False
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ False
tactic: rw [lt_min_iff] at H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ False
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ x (firstDiff x z) = z (firstDiff x z)
tactic: refine apply_firstDiff_ne h ?_
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ x (firstDiff x z) = z (firstDiff x z)
state_after: no goals
tactic: calc
    x (firstDiff x z) = y (firstDiff x z) := apply_eq_of_lt_firstDiff H.1
    _ = z (firstDiff x z) := apply_eq_of_lt_firstDiff H.2
Theorem: Real.mul_le_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ 2 / π * x ≤ sin x
state_after: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ (π / 2)⁻¹ * x ≤ sin x
tactic: rw [← inv_div]
state_before: x : ℝ
hx : 0 ≤ x
hx' : x ≤ π / 2
⊢ (π / 2)⁻¹ * x ≤ sin x
state_after: no goals
tactic: simpa [-inv_div, mul_inv_cancel_left₀ pi_div_two_pos.ne'] using @le_sin_mul ((π / 2)⁻¹ * x)
    (mul_nonneg (inv_nonneg.2 pi_div_two_pos.le) hx)
    (by rwa [← div_eq_inv_mul, div_le_one pi_div_two_pos])
Theorem: commProb_pi
File: Mathlib/GroupTheory/CommutingProbability.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ commProb ((a : α) → i a) = ∏ a : α, commProb (i a)
state_after: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ ↑(Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a }) / ↑(Nat.card ((a : α) → i a)) ^ 2 =
    ↑(Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })) / ↑(Nat.card ((a : α) → i a)) ^ 2
tactic: simp_rw [commProb_def, Finset.prod_div_distrib, Finset.prod_pow, ← Nat.cast_prod,
    ← Nat.card_pi, Commute, SemiconjBy, Function.funext_iff]
state_before: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ ↑(Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a }) / ↑(Nat.card ((a : α) → i a)) ^ 2 =
    ↑(Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })) / ↑(Nat.card ((a : α) → i a)) ^ 2
state_after: case e_a.e_a
M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a } = Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })
tactic: congr 2
state_before: case e_a.e_a
M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a } = Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })
state_after: no goals
tactic: exact Nat.card_congr ⟨fun x a => ⟨⟨x.1.1 a, x.1.2 a⟩, x.2 a⟩, fun x => ⟨⟨fun a => (x a).1.1,
    fun a => (x a).1.2⟩, fun a => (x a).2⟩, fun x => rfl, fun x => rfl⟩
Theorem: IsSimpleGroup.prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
⊢ Nat.Prime (Fintype.card α)
state_after: α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
⊢ Nat.Prime (Fintype.card α)
tactic: have h0 : 0 < Fintype.card α := Fintype.card_pos_iff.2 (by infer_instance)
state_before: α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
⊢ Nat.Prime (Fintype.card α)
state_after: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ Nat.Prime (Fintype.card α)
tactic: obtain ⟨g, hg⟩ := IsCyclic.exists_generator (α := α)
state_before: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ Nat.Prime (Fintype.card α)
state_after: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ 2 ≤ Fintype.card α ∧ ∀ (m : ℕ), m ∣ Fintype.card α → m = 1 ∨ m = Fintype.card α
tactic: rw [Nat.prime_def_lt'']
state_before: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ 2 ≤ Fintype.card α ∧ ∀ (m : ℕ), m ∣ Fintype.card α → m = 1 ∨ m = Fintype.card α
state_after: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
n : ℕ
hn : n ∣ Fintype.card α
⊢ n = 1 ∨ n = Fintype.card α
tactic: refine ⟨Fintype.one_lt_card_iff_nontrivial.2 inferInstance, fun n hn => ?_⟩
state_before: case intro
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
n : ℕ
hn : n ∣ Fintype.card α
⊢ n = 1 ∨ n = Fintype.card α
state_after: case intro.refine_1
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
n : ℕ
hn : n ∣ Fintype.card α
⊢ Subgroup.zpowers (g ^ n) = ⊤ → n = 1

case intro.refine_2
α : Type u
a : α
inst✝² : CommGroup α
inst✝¹ : IsSimpleGroup α
inst✝ : Fintype α
h0 : 0 < Fintype.card α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
n : ℕ
hn : n ∣ Fintype.card α
⊢ Subgroup.zpowers (g ^ n) = ⊥ → n = Fintype.card α
tactic: refine (IsSimpleOrder.eq_bot_or_eq_top (Subgroup.zpowers (g ^ n))).symm.imp ?_ ?_
Theorem: MvPolynomial.DirectSum.coeLinearMap_eq_dfinsupp_sum
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommSemiring R
σ : Type u_3
inst✝³ : AddCommMonoid M
w : σ → M
n : M
φ ψ : MvPolynomial σ R
inst✝² : DecidableEq σ
inst✝¹ : DecidableEq R
inst✝ : DecidableEq M
x : ⨁ (i : M), ↥(weightedHomogeneousSubmodule R w i)
⊢ (coeLinearMap fun i => weightedHomogeneousSubmodule R w i) x = DFinsupp.sum x fun x x_1 => ↑x_1
state_after: no goals
tactic: rw [_root_.DirectSum.coeLinearMap_eq_dfinsupp_sum]
Theorem: Collinear.collinear_insert_iff_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
⊢ Collinear k (insert p₁ s) ↔ Collinear k {p₁, p₂, p₃}
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
hv : vectorSpan k (insert p₁ s) = vectorSpan k {p₁, p₂, p₃}
⊢ Collinear k (insert p₁ s) ↔ Collinear k {p₁, p₂, p₃}
tactic: have hv : vectorSpan k (insert p₁ s) = vectorSpan k ({p₁, p₂, p₃} : Set P) := by
    -- Porting note: Original proof used `conv_lhs` and `conv_rhs`, but these tactics timed out.
    rw [← direction_affineSpan, ← affineSpan_insert_affineSpan]
    symm
    rw [← direction_affineSpan, ← affineSpan_insert_affineSpan, h.affineSpan_eq_of_ne hp₂ hp₃ hp₂p₃]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
hv : vectorSpan k (insert p₁ s) = vectorSpan k {p₁, p₂, p₃}
⊢ Collinear k (insert p₁ s) ↔ Collinear k {p₁, p₂, p₃}
state_after: no goals
tactic: rw [Collinear, Collinear, hv]
Theorem: Finset.sup_singleton''
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
s : Finset β
f : β → α
⊢ (s.sup fun b => {f b}) = image f s
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
s : Finset β
f : β → α
a : α
⊢ (a ∈ s.sup fun b => {f b}) ↔ a ∈ image f s
tactic: ext a
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
s : Finset β
f : β → α
a : α
⊢ (a ∈ s.sup fun b => {f b}) ↔ a ∈ image f s
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
s : Finset β
f : β → α
a : α
⊢ (∃ v ∈ s, a ∈ {f v}) ↔ ∃ a_1 ∈ s, f a_1 = a
tactic: rw [mem_sup, mem_image]
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DecidableEq α
s : Finset β
f : β → α
a : α
⊢ (∃ v ∈ s, a ∈ {f v}) ↔ ∃ a_1 ∈ s, f a_1 = a
state_after: no goals
tactic: simp only [mem_singleton, eq_comm]
Theorem: List.sum_concat
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
⊢ (l.concat a).prod = l.prod * a
state_after: no goals
tactic: rw [concat_eq_append, prod_append, prod_singleton]
Theorem: Finset.pairwise_cons'
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ _root_.Pairwise (r on fun a_1 => f ↑a_1) ↔
    _root_.Pairwise (r on fun a => f ↑a) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ (↑s).Pairwise (r on f) → ((∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a) ↔ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a))
tactic: simp only [pairwise_subtype_iff_pairwise_finset', Finset.coe_cons, Set.pairwise_insert,
    Finset.mem_coe, and_congr_right_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
ha : a ∉ s
r : β → β → Prop
f : α → β
⊢ (↑s).Pairwise (r on f) → ((∀ b ∈ s, a ≠ b → (r on f) a b ∧ (r on f) b a) ↔ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a))
state_after: no goals
tactic: exact fun _ =>
    ⟨fun h b hb =>
      h b hb <| by
        rintro rfl
        contradiction,
      fun h b hb _ => h b hb⟩
Theorem: Topology.IsLower.continuous_iff_Ici
File: Mathlib/Topology/Order/LowerUpperTopology.lean

Proof steps:
state_before: α : Type u_2
β : Type u_1
inst✝³ : Preorder α
inst✝² : TopologicalSpace α
inst✝¹ : IsLower α
s : Set α
inst✝ : TopologicalSpace β
f : β → α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)
state_after: α : Type u_2
β : Type u_1
inst✝² : Preorder α
s : Set α
inst✝¹ : TopologicalSpace β
f : β → α
inst✝ : IsLower α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)
tactic: obtain rfl := IsLower.topology_eq α
state_before: α : Type u_2
β : Type u_1
inst✝² : Preorder α
s : Set α
inst✝¹ : TopologicalSpace β
f : β → α
inst✝ : IsLower α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)
state_after: no goals
tactic: simp [continuous_generateFrom_iff]
Theorem: isEmpty_psum
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
α : Sort u_4
β : Sort u_5
⊢ IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_psum, not_or]
Theorem: SequentialSpace.iSup
File: Mathlib/Topology/Sequences.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
⊢ SequentialSpace X
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this : TopologicalSpace X := ⨆ i, t i
⊢ SequentialSpace X
tactic: letI : TopologicalSpace X := ⨆ i, t i
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this : TopologicalSpace X := ⨆ i, t i
⊢ SequentialSpace X
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this : TopologicalSpace X := ⨆ i, t i
s : Set X
hs : IsSeqClosed s
i : ι
⊢ IsClosed s
tactic: refine ⟨fun s hs ↦ isClosed_iSup_iff.2 fun i ↦ ?_⟩
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this : TopologicalSpace X := ⨆ i, t i
s : Set X
hs : IsSeqClosed s
i : ι
⊢ IsClosed s
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this✝ : TopologicalSpace X := ⨆ i, t i
s : Set X
hs : IsSeqClosed s
i : ι
this : TopologicalSpace X := t i
⊢ IsClosed s
tactic: letI := t i
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
ι : Sort u_3
t : ι → TopologicalSpace X
h : ∀ (i : ι), SequentialSpace X
this✝ : TopologicalSpace X := ⨆ i, t i
s : Set X
hs : IsSeqClosed s
i : ι
this : TopologicalSpace X := t i
⊢ IsClosed s
state_after: no goals
tactic: exact IsSeqClosed.isClosed fun u x hus hux ↦ hs hus <| hux.mono_right <| nhds_mono <| le_iSup _ _