ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Subgroup.characteristic_iff_map_le
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
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), map ϕ.toMonoidHom H ≤ H
state_after: 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
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H ≤ H
tactic: simp_rw [map_equiv_eq_comap_symm']
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
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H ≤ H
state_after: no goals
tactic: exact characteristic_iff_comap_le.trans ⟨fun h ϕ => h ϕ.symm, fun h ϕ => h ϕ.symm⟩
Theorem: Submodule.comm_trans_rTensorOne
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
⊢ TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne = M.lTensorOne
state_after: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
tactic: refine LinearEquiv.toLinearMap_injective <| TensorProduct.ext' fun r m ↦ ?_
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R S) x = ↑r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
tactic: obtain ⟨x, h⟩ := Algebra.mem_bot.1 r.2
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R S) x = ↑r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
tactic: replace h : algebraMap R _ x = r := Subtype.val_injective h
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) (r ⊗ₜ[R] m) = ↑M.lTensorOne (r ⊗ₜ[R] m)
state_after: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) ((algebraMap R ↥⊥) x ⊗ₜ[R] m) =
    ↑M.lTensorOne ((algebraMap R ↥⊥) x ⊗ₜ[R] m)
tactic: rw [← h]
state_before: case intro
R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
r : ↥⊥
m : ↥M
x : R
h : (algebraMap R ↥⊥) x = r
⊢ ↑(TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne) ((algebraMap R ↥⊥) x ⊗ₜ[R] m) =
    ↑M.lTensorOne ((algebraMap R ↥⊥) x ⊗ₜ[R] m)
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Term.realize_restrictVarLeft
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ✝ : Type u_3
inst✝ : DecidableEq α
γ : Type u_4
t : L.Term (α ⊕ γ)
s : Set α
h : ↑t.varFinsetLeft ⊆ s
v : α → M
xs : γ → M
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (t.restrictVarLeft (Set.inclusion h)) = realize (Sum.elim v xs) t
state_after: case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ✝ : Type u_3
inst✝ : DecidableEq α
γ : Type u_4
s : Set α
v : α → M
xs : γ → M
a : α ⊕ γ
h : ↑(var a).varFinsetLeft ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) ((var a).restrictVarLeft (Set.inclusion h)) = realize (Sum.elim v xs) (var a)

case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ✝ : Type u_3
inst✝ : DecidableEq α
γ : Type u_4
s : Set α
v : α → M
xs : γ → M
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term (α ⊕ γ)
ih :
  ∀ (a : Fin l✝) (h : ↑(_ts✝ a).varFinsetLeft ⊆ s),
    realize (Sum.elim (v ∘ Subtype.val) xs) ((_ts✝ a).restrictVarLeft (Set.inclusion h)) =
      realize (Sum.elim v xs) (_ts✝ a)
h : ↑(func _f✝ _ts✝).varFinsetLeft ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) ((func _f✝ _ts✝).restrictVarLeft (Set.inclusion h)) =
    realize (Sum.elim v xs) (func _f✝ _ts✝)
tactic: induction' t with a _ _ _ ih
Theorem: ZMod.eq_zero_iff_gcd_ne_one
File: Mathlib/Data/ZMod/Coprime.lean

Proof steps:
state_before: a : ℤ
p : ℕ
pp : Fact (Nat.Prime p)
⊢ ↑a = 0 ↔ a.gcd ↑p ≠ 1
state_after: no goals
tactic: rw [Ne, Int.gcd_comm, Int.gcd_eq_one_iff_coprime,
    (Nat.prime_iff_prime_int.1 pp.1).coprime_iff_not_dvd, Classical.not_not,
    intCast_zmod_eq_zero_iff_dvd]
Theorem: Algebra.PreSubmersivePresentation.jacobian_eq_jacobiMatrix_det
File: Mathlib/RingTheory/Smooth/StandardSmooth.lean

Proof steps:
state_before: n : ℕ
R : Type u
inst✝⁴ : CommRing R
S : Type v
inst✝³ : CommRing S
inst✝² : Algebra R S
P : PreSubmersivePresentation R S
inst✝¹ : Fintype P.rels
inst✝ : DecidableEq P.rels
⊢ P.jacobian = (algebraMap P.Ring S) P.jacobiMatrix.det
state_after: no goals
tactic: simp [jacobiMatrix, jacobian]
Theorem: Int.csSup_eq_greatest_of_bdd
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

Proof steps:
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ z ∈ s, z ≤ b
Hinh : ∃ z, z ∈ s
⊢ sSup s = ↑(b.greatestOfBdd Hb Hinh)
state_after: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ z ∈ s, z ≤ b
Hinh : ∃ z, z ∈ s
this : s.Nonempty ∧ BddAbove s
⊢ sSup s = ↑(b.greatestOfBdd Hb Hinh)
tactic: have : s.Nonempty ∧ BddAbove s := ⟨Hinh, b, Hb⟩
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ z ∈ s, z ≤ b
Hinh : ∃ z, z ∈ s
this : s.Nonempty ∧ BddAbove s
⊢ sSup s = ↑(b.greatestOfBdd Hb Hinh)
state_after: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ z ∈ s, z ≤ b
Hinh : ∃ z, z ∈ s
this : s.Nonempty ∧ BddAbove s
⊢ ↑((Classical.choose ⋯).greatestOfBdd ⋯ ⋯) = ↑(b.greatestOfBdd Hb Hinh)
tactic: simp only [sSup, this, and_self, dite_true]
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ z ∈ s, z ≤ b
Hinh : ∃ z, z ∈ s
this : s.Nonempty ∧ BddAbove s
⊢ ↑((Classical.choose ⋯).greatestOfBdd ⋯ ⋯) = ↑(b.greatestOfBdd Hb Hinh)
state_after: no goals
tactic: convert (coe_greatestOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddAbove s)) Hinh).symm
Theorem: Continuous.path_trans
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
f : Y → Path x y
g : Y → Path y z
⊢ Continuous f → Continuous g → Continuous fun t => (f t).trans (g t)
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous fun t => (f t).trans (g t)
tactic: intro hf hg
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous fun t => (f t).trans (g t)
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous ↿fun t => (f t).trans (g t)
tactic: apply continuous_uncurry_iff.mp
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous ↿fun t => (f t).trans (g t)
state_after: no goals
tactic: exact trans_continuous_family _ (continuous_uncurry_iff.mpr hf) _ (continuous_uncurry_iff.mpr hg)
Theorem: CategoryTheory.NatTrans.equifibered_of_discrete
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

Proof steps:
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.8704, u_1} K
D : Type u_2
inst✝ : Category.{?u.8711, u_2} D
ι : Type u_3
F G : Discrete ι ⥤ C
α : F ⟶ G
⊢ Equifibered α
state_after: case mk.mk.up.up
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.8704, u_1} K
D : Type u_2
inst✝ : Category.{?u.8711, u_2} D
ι : Type u_3
F G : Discrete ι ⥤ C
α : F ⟶ G
i : ι
⊢ IsPullback (F.map { down := { down := ⋯ } }) (α.app { as := i }) (α.app { as := i }) (G.map { down := { down := ⋯ } })
tactic: rintro ⟨i⟩ ⟨j⟩ ⟨⟨rfl : i = j⟩⟩
state_before: case mk.mk.up.up
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.8704, u_1} K
D : Type u_2
inst✝ : Category.{?u.8711, u_2} D
ι : Type u_3
F G : Discrete ι ⥤ C
α : F ⟶ G
i : ι
⊢ IsPullback (F.map { down := { down := ⋯ } }) (α.app { as := i }) (α.app { as := i }) (G.map { down := { down := ⋯ } })
state_after: case mk.mk.up.up
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.8704, u_1} K
D : Type u_2
inst✝ : Category.{?u.8711, u_2} D
ι : Type u_3
F G : Discrete ι ⥤ C
α : F ⟶ G
i : ι
⊢ IsPullback (𝟙 (F.obj { as := i })) (α.app { as := i }) (α.app { as := i }) (𝟙 (G.obj { as := i }))
tactic: simp only [Discrete.functor_map_id]
state_before: case mk.mk.up.up
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.8704, u_1} K
D : Type u_2
inst✝ : Category.{?u.8711, u_2} D
ι : Type u_3
F G : Discrete ι ⥤ C
α : F ⟶ G
i : ι
⊢ IsPullback (𝟙 (F.obj { as := i })) (α.app { as := i }) (α.app { as := i }) (𝟙 (G.obj { as := i }))
state_after: no goals
tactic: exact IsPullback.of_horiz_isIso ⟨by rw [Category.id_comp, Category.comp_id]⟩
Theorem: AddMonoidHom.noncommPiCoprod_range
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
⊢ (noncommPiCoprod ϕ hcomm).range = ⨆ i, (ϕ i).range
state_after: G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
this : DecidableEq ι := Classical.decEq ι
⊢ (noncommPiCoprod ϕ hcomm).range = ⨆ i, (ϕ i).range
tactic: letI := Classical.decEq ι
state_before: G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
this : DecidableEq ι := Classical.decEq ι
⊢ (noncommPiCoprod ϕ hcomm).range = ⨆ i, (ϕ i).range
state_after: case a
G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
this : DecidableEq ι := Classical.decEq ι
⊢ (noncommPiCoprod ϕ hcomm).range ≤ ⨆ i, (ϕ i).range

case a
G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
this : DecidableEq ι := Classical.decEq ι
⊢ ⨆ i, (ϕ i).range ≤ (noncommPiCoprod ϕ hcomm).range
tactic: apply le_antisymm
Theorem: Batteries.RBNode.All.setRed
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p t.setRed
state_after: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p
    (match t with
    | node c a v b => node red a v b
    | nil => nil)
tactic: unfold setRed
state_before: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p
    (match t with
    | node c a v b => node red a v b
    | nil => nil)
state_after: no goals
tactic: split <;> simp_all
Theorem: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProduct_bijective_of_map_from_fin
File: Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹⁰ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
N : Type u_3
inst✝⁷ : AddCommGroup N
inst✝⁶ : Module R✝ N
R : Type u
inst✝⁵ : CommRing R
I : Ideal R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : IsNoetherianRing R
ι : Type
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
⊢ Function.Bijective ⇑(ofTensorProduct I M)
state_after: R✝ : Type u_1
inst✝¹⁰ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
N : Type u_3
inst✝⁷ : AddCommGroup N
inst✝⁶ : Module R✝ N
R : Type u
inst✝⁵ : CommRing R
I : Ideal R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : IsNoetherianRing R
ι : Type
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
this : IsIso (ModuleCat.ofHom (ofTensorProduct I M))
⊢ Function.Bijective ⇑(ofTensorProduct I M)
tactic: have : IsIso (ModuleCat.ofHom (ofTensorProduct I M)) :=
    ofTensorProduct_iso I M f hf
state_before: R✝ : Type u_1
inst✝¹⁰ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁹ : AddCommGroup M✝
inst✝⁸ : Module R✝ M✝
N : Type u_3
inst✝⁷ : AddCommGroup N
inst✝⁶ : Module R✝ N
R : Type u
inst✝⁵ : CommRing R
I : Ideal R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : IsNoetherianRing R
ι : Type
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
f : (ι → R) →ₗ[R] M
hf : Function.Surjective ⇑f
this : IsIso (ModuleCat.ofHom (ofTensorProduct I M))
⊢ Function.Bijective ⇑(ofTensorProduct I M)
state_after: no goals
tactic: exact ConcreteCategory.bijective_of_isIso (ModuleCat.ofHom (ofTensorProduct I M))
Theorem: Subgroup.closure_closure_coe_preimage
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
H K : Subgroup G
k✝ k : Set G
x✝¹ : { x // x ∈ ↑(closure k) }
x : G
hx : x ∈ ↑(closure k)
x✝ : ⟨x, hx⟩ ∈ ⊤
⊢ ⟨x, hx⟩ ∈ closure (Subtype.val ⁻¹' k)
state_after: case refine_1
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
H K : Subgroup G
k✝ k : Set G
x✝¹ : { x // x ∈ ↑(closure k) }
x : G
hx : x ∈ ↑(closure k)
x✝ : ⟨x, hx⟩ ∈ ⊤
g : G
hg : g ∈ k
⊢ ⟨g, ⋯⟩ ∈ closure (Subtype.val ⁻¹' k)

case refine_2
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
H K : Subgroup G
k✝ k : Set G
x✝¹ : { x // x ∈ ↑(closure k) }
x : G
hx : x ∈ ↑(closure k)
x✝ : ⟨x, hx⟩ ∈ ⊤
⊢ ⟨1, ⋯⟩ ∈ closure (Subtype.val ⁻¹' k)

case refine_3
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
H K : Subgroup G
k✝ k : Set G
x✝¹ : { x // x ∈ ↑(closure k) }
x : G
hx : x ∈ ↑(closure k)
x✝ : ⟨x, hx⟩ ∈ ⊤
g₁ : G
g₂ : g₁ ∈ closure k
hg₁ : G
hg₂ : hg₁ ∈ closure k
⊢ ⟨g₁, g₂⟩ ∈ closure (Subtype.val ⁻¹' k) →
    ⟨hg₁, hg₂⟩ ∈ closure (Subtype.val ⁻¹' k) → ⟨g₁ * hg₁, ⋯⟩ ∈ closure (Subtype.val ⁻¹' k)

case refine_4
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
H K : Subgroup G
k✝ k : Set G
x✝¹ : { x // x ∈ ↑(closure k) }
x : G
hx : x ∈ ↑(closure k)
x✝ : ⟨x, hx⟩ ∈ ⊤
g : G
hg : g ∈ closure k
⊢ ⟨g, hg⟩ ∈ closure (Subtype.val ⁻¹' k) → ⟨g⁻¹, ⋯⟩ ∈ closure (Subtype.val ⁻¹' k)
tactic: refine closure_induction' (fun g hg => ?_) ?_ (fun g₁ g₂ hg₁ hg₂ => ?_) (fun g hg => ?_) hx
Theorem: Polynomial.isNilpotent_aeval_sub_of_isNilpotent_sub
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

Proof steps:
state_before: R✝ : Type u_1
r : R✝
R : Type u_2
S : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
a b : S
h : IsNilpotent (a - b)
⊢ IsNilpotent ((aeval a) P - (aeval b) P)
state_after: R✝ : Type u_1
r : R✝
R : Type u_2
S : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
a b : S
h : IsNilpotent (a - b)
⊢ IsNilpotent (eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P))
tactic: simp only [← eval_map_algebraMap]
state_before: R✝ : Type u_1
r : R✝
R : Type u_2
S : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
a b : S
h : IsNilpotent (a - b)
⊢ IsNilpotent (eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P))
state_after: R✝ : Type u_1
r : R✝
R : Type u_2
S : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
a b : S
h : IsNilpotent (a - b)
c : S
hc : eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P) = c * (a - b)
⊢ IsNilpotent (eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P))
tactic: have ⟨c, hc⟩ := evalSubFactor (map (algebraMap R S) P) a b
state_before: R✝ : Type u_1
r : R✝
R : Type u_2
S : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
a b : S
h : IsNilpotent (a - b)
c : S
hc : eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P) = c * (a - b)
⊢ IsNilpotent (eval a (map (algebraMap R S) P) - eval b (map (algebraMap R S) P))
state_after: no goals
tactic: exact hc ▸ (Commute.all _ _).isNilpotent_mul_right h
Theorem: List.zipWith_distrib_reverse
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : l.length = l'.length
⊢ (zipWith f l l').reverse = zipWith f l.reverse l'.reverse
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
n : ℕ
l' : List β
h : [].length = l'.length
⊢ (zipWith f [] l').reverse = zipWith f [].reverse l'.reverse

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
n : ℕ
hd : α
tl : List α
hl : ∀ (l' : List β), tl.length = l'.length → (zipWith f tl l').reverse = zipWith f tl.reverse l'.reverse
l' : List β
h : (hd :: tl).length = l'.length
⊢ (zipWith f (hd :: tl) l').reverse = zipWith f (hd :: tl).reverse l'.reverse
tactic: induction' l with hd tl hl generalizing l'
Theorem: RelSeries.ext
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
x y : RelSeries r
length_eq : x.length = y.length
⊢ x.length + 1 = y.length + 1
state_after: no goals
tactic: rw [length_eq]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
x y : RelSeries r
length_eq : x.length = y.length
toFun_eq : x.toFun = y.toFun ∘ Fin.cast ⋯
⊢ x = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : { length := nx, toFun := fx, step := step✝ }.length = y.length
toFun_eq : { length := nx, toFun := fx, step := step✝ }.toFun = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
tactic: rcases x with ⟨nx, fx⟩
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : { length := nx, toFun := fx, step := step✝ }.length = y.length
toFun_eq : { length := nx, toFun := fx, step := step✝ }.toFun = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : nx = y.length
toFun_eq : fx = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
tactic: dsimp only at length_eq toFun_eq
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : nx = y.length
toFun_eq : fx = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
step✝ : ∀ (i : Fin y.length), r ((y.toFun ∘ Fin.cast ⋯) i.castSucc) ((y.toFun ∘ Fin.cast ⋯) i.succ)
⊢ { length := y.length, toFun := y.toFun ∘ Fin.cast ⋯, step := step✝ } = y
tactic: subst length_eq toFun_eq
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
step✝ : ∀ (i : Fin y.length), r ((y.toFun ∘ Fin.cast ⋯) i.castSucc) ((y.toFun ∘ Fin.cast ⋯) i.succ)
⊢ { length := y.length, toFun := y.toFun ∘ Fin.cast ⋯, step := step✝ } = y
state_after: no goals
tactic: rfl
Theorem: mfderiv_zero_of_not_mdifferentiableAt
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f f₀ f₁ : M → M'
x : M
s t : Set M
g : M' → M''
u : Set M'
Is : SmoothManifoldWithCorners I M
I's : SmoothManifoldWithCorners I' M'
I''s : SmoothManifoldWithCorners I'' M''
f' f₀' f₁' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)
g' : TangentSpace I' (f x) →L[𝕜] TangentSpace I'' (g (f x))
h : ¬MDifferentiableAt I I' f x
⊢ mfderiv I I' f x = 0
state_after: no goals
tactic: simp only [mfderiv, h, if_neg, not_false_iff]
Theorem: Equiv.tsum_eq
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
e : γ ≃ β
f : β → α
⊢ mulSupport f ⊆ Set.range ⇑e
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShiftedHom.comp_neg
File: Mathlib/CategoryTheory/Shift/ShiftedHom.lean

Proof steps:
state_before: C : Type u_1
inst✝⁸ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁷ : Category.{?u.42059, u_2} D
E : Type u_3
inst✝⁶ : Category.{?u.42066, u_3} E
M : Type u_4
inst✝⁵ : AddMonoid M
inst✝⁴ : HasShift C M
inst✝³ : HasShift D M
inst✝² : HasShift E M
X Y Z T : C
inst✝¹ : Preadditive C
inst✝ : ∀ (a : M), (shiftFunctor C a).Additive
a b c : M
α : ShiftedHom X Y a
β : ShiftedHom Y Z b
h : b + a = c
⊢ α.comp (-β) h = -α.comp β h
state_after: no goals
tactic: rw [comp, comp, Functor.map_neg, Preadditive.neg_comp, Preadditive.comp_neg]