ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsAddGroupHom.trivial_ker_of_injective
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
hx : x ∈ ker f
⊢ x ∈ IsSubgroup.trivial G
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
hx : x ∈ ker f
⊢ f x = f 1
tactic: suffices f x = f 1 by simpa using h this
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
hx : x ∈ ker f
⊢ f x = f 1
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
hx : x ∈ ker f
⊢ f x = 1
tactic: simp [hf.map_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
hx : x ∈ ker f
⊢ f x = 1
state_after: no goals
tactic: rwa [mem_ker] at hx
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : Injective f
x : G
⊢ x ∈ IsSubgroup.trivial G → x ∈ ker f
state_after: no goals
tactic: simp (config := { contextual := true }) [mem_ker, hf.map_one]
Theorem: List.rotate_length_mul
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate (l.length * n) = l
state_after: no goals
tactic: rw [rotate_eq_rotate', rotate'_length_mul]
Theorem: SimpleGraph.TripartiteFromTriangles.cliqueFinset_eq_map
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝⁷ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝⁶ : DecidableEq α
inst✝⁵ : DecidableEq β
inst✝⁴ : DecidableEq γ
inst✝³ : Fintype α
inst✝² : Fintype β
inst✝¹ : Fintype γ
inst✝ : NoAccidental t
⊢ (graph t).cliqueFinset 3 = map toTriangle t
state_after: no goals
tactic: simp [cliqueFinset_eq_image, map_eq_image]
Theorem: Fintype.card_piFinset_const
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α✝¹ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α✝ : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α✝ i)
α : Type u_7
s : Finset α
n : ℕ
⊢ (piFinset fun x => s).card = s.card ^ n
state_after: no goals
tactic: simp
Theorem: UniformOnFun.precomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ UniformContinuous fun g => (ofFun 𝔗) ((toFun 𝔖) g ∘ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ ∀ i ∈ 𝔗,
    ∀ i_2 ∈ 𝓤 β,
      Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f)))
        (⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V)) (𝓟 (UniformOnFun.gen 𝔗 i i_2))
tactic: simp_rw [UniformContinuous, UniformOnFun.uniformity_eq, tendsto_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
⊢ ∀ i ∈ 𝔗,
    ∀ i_2 ∈ 𝓤 β,
      Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f)))
        (⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V)) (𝓟 (UniformOnFun.gen 𝔗 i i_2))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
t : Set γ
ht : t ∈ 𝔗
V : Set (β × β)
hV : V ∈ 𝓤 β
⊢ Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f))) (𝓟 (UniformOnFun.gen 𝔖 (f '' t) V))
    (𝓟 (UniformOnFun.gen 𝔗 t V))
tactic: refine fun t ht V hV ↦ tendsto_iInf' (f '' t) <| tendsto_iInf' (hf ht) <|
    tendsto_iInf' V <| tendsto_iInf' hV ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
𝔗 : Set (Set γ)
f : γ → α
hf : MapsTo (fun x => f '' x) 𝔗 𝔖
t : Set γ
ht : t ∈ 𝔗
V : Set (β × β)
hV : V ∈ 𝓤 β
⊢ Tendsto (fun x => ((ofFun 𝔗) ((toFun 𝔖) x.1 ∘ f), (ofFun 𝔗) ((toFun 𝔖) x.2 ∘ f))) (𝓟 (UniformOnFun.gen 𝔖 (f '' t) V))
    (𝓟 (UniformOnFun.gen 𝔗 t V))
state_after: no goals
tactic: simpa only [tendsto_principal_principal, UniformOnFun.gen] using fun _ ↦ forall_mem_image.1
Theorem: cauchy_pi_iff
File: Mathlib/Topology/UniformSpace/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
β : Type u_3
α : ι → Type u
U : (i : ι) → UniformSpace (α i)
inst✝¹ : UniformSpace β
inst✝ : Nonempty ι
l : Filter ((i : ι) → α i)
⊢ Cauchy l ↔ ∀ (i : ι), Cauchy (map (eval i) l)
state_after: no goals
tactic: simp_rw [Pi.uniformSpace_eq, cauchy_iInf_uniformSpace, cauchy_comap_uniformSpace]
Theorem: DFinsupp.comapDomain'_zero
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
⊢ comapDomain' h hh' 0 = 0
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
i✝ : κ
⊢ (comapDomain' h hh' 0) i✝ = 0 i✝
tactic: ext
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
h' : ι → κ
hh' : Function.LeftInverse h' h
i✝ : κ
⊢ (comapDomain' h hh' 0) i✝ = 0 i✝
state_after: no goals
tactic: rw [zero_apply, comapDomain'_apply, zero_apply]
Theorem: Polynomial.taylor_injective
File: Mathlib/Algebra/Polynomial/Taylor.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
⊢ Function.Injective ⇑(taylor r)
state_after: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : (taylor r) f = (taylor r) g
⊢ f = g
tactic: intro f g h
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : (taylor r) f = (taylor r) g
⊢ f = g
state_after: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : (taylor (-r)) ((taylor r) f) = (taylor (-r)) ((taylor r) g)
⊢ f = g
tactic: apply_fun taylor (-r) at h
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : (taylor (-r)) ((taylor r) f) = (taylor (-r)) ((taylor r) g)
⊢ f = g
state_after: no goals
tactic: simpa only [taylor_apply, comp_assoc, add_comp, X_comp, C_comp, C_neg, neg_add_cancel_right,
    comp_X] using h
Theorem: LinearMap.toMatrix_smulBasis_right
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁹ : Fintype n
inst✝⁸ : Finite m
inst✝⁷ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
G : Type u_7
inst✝² : Group G
inst✝¹ : DistribMulAction G M₂
inst✝ : SMulCommClass G R M₂
g : G
f : M₁ →ₗ[R] M₂
⊢ (toMatrix v₁ (g • v₂)) f = (toMatrix v₁ v₂) (DistribMulAction.toLinearMap R M₂ g⁻¹ ∘ₗ f)
state_after: case a
R : Type u_1
inst✝¹⁰ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁹ : Fintype n
inst✝⁸ : Finite m
inst✝⁷ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
G : Type u_7
inst✝² : Group G
inst✝¹ : DistribMulAction G M₂
inst✝ : SMulCommClass G R M₂
g : G
f : M₁ →ₗ[R] M₂
i✝ : m
j✝ : n
⊢ (toMatrix v₁ (g • v₂)) f i✝ j✝ = (toMatrix v₁ v₂) (DistribMulAction.toLinearMap R M₂ g⁻¹ ∘ₗ f) i✝ j✝
tactic: ext
state_before: case a
R : Type u_1
inst✝¹⁰ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁹ : Fintype n
inst✝⁸ : Finite m
inst✝⁷ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
G : Type u_7
inst✝² : Group G
inst✝¹ : DistribMulAction G M₂
inst✝ : SMulCommClass G R M₂
g : G
f : M₁ →ₗ[R] M₂
i✝ : m
j✝ : n
⊢ (toMatrix v₁ (g • v₂)) f i✝ j✝ = (toMatrix v₁ v₂) (DistribMulAction.toLinearMap R M₂ g⁻¹ ∘ₗ f) i✝ j✝
state_after: case a
R : Type u_1
inst✝¹⁰ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁹ : Fintype n
inst✝⁸ : Finite m
inst✝⁷ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
G : Type u_7
inst✝² : Group G
inst✝¹ : DistribMulAction G M₂
inst✝ : SMulCommClass G R M₂
g : G
f : M₁ →ₗ[R] M₂
i✝ : m
j✝ : n
⊢ ((g • v₂).repr (f (v₁ j✝))) i✝ = (v₂.repr ((DistribMulAction.toLinearMap R M₂ g⁻¹ ∘ₗ f) (v₁ j✝))) i✝
tactic: rw [LinearMap.toMatrix_apply, LinearMap.toMatrix_apply]
state_before: case a
R : Type u_1
inst✝¹⁰ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁹ : Fintype n
inst✝⁸ : Finite m
inst✝⁷ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁶ : AddCommMonoid M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
G : Type u_7
inst✝² : Group G
inst✝¹ : DistribMulAction G M₂
inst✝ : SMulCommClass G R M₂
g : G
f : M₁ →ₗ[R] M₂
i✝ : m
j✝ : n
⊢ ((g • v₂).repr (f (v₁ j✝))) i✝ = (v₂.repr ((DistribMulAction.toLinearMap R M₂ g⁻¹ ∘ₗ f) (v₁ j✝))) i✝
state_after: no goals
tactic: dsimp
Theorem: MeasureTheory.Submartingale.exists_ae_tendsto_of_bdd
File: Mathlib/Probability/Martingale/Convergence.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) 1 μ ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ∃ c, Tendsto (fun n => f n ω) atTop (𝓝 c)
state_after: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω✝ : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) 1 μ ≤ ↑R
ω : Ω
h₁ : ∀ (a b : ℚ), a < b → upcrossings (↑a) (↑b) f ω < ⊤
h₂ : liminf (fun n => ↑‖f n ω‖₊) atTop < ⊤
⊢ ∃ c, Tendsto (fun n => f n ω) atTop (𝓝 c)
tactic: filter_upwards [hf.upcrossings_ae_lt_top hbdd, ae_bdd_liminf_atTop_of_eLpNorm_bdd one_ne_zero
    (fun n => (hf.stronglyMeasurable n).measurable.mono (ℱ.le n) le_rfl) hbdd] with ω h₁ h₂
state_before: case h
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω✝ : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), eLpNorm (f n) 1 μ ≤ ↑R
ω : Ω
h₁ : ∀ (a b : ℚ), a < b → upcrossings (↑a) (↑b) f ω < ⊤
h₂ : liminf (fun n => ↑‖f n ω‖₊) atTop < ⊤
⊢ ∃ c, Tendsto (fun n => f n ω) atTop (𝓝 c)
state_after: no goals
tactic: exact tendsto_of_uncrossing_lt_top h₂ h₁
Theorem: Algebra.norm_eq_zero_iff_of_basis
File: Mathlib/RingTheory/Norm/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field F
inst✝⁴ : Algebra K L
inst✝³ : Algebra K F
ι : Type w
inst✝² : Finite ι
inst✝¹ : IsDomain R
inst✝ : IsDomain S
b : Basis ι R S
x : S
⊢ (norm R) x = 0 ↔ x = 0
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field F
inst✝⁴ : Algebra K L
inst✝³ : Algebra K F
ι : Type w
inst✝² : Finite ι
inst✝¹ : IsDomain R
inst✝ : IsDomain S
b : Basis ι R S
x : S
this : Module.Free R S
⊢ (norm R) x = 0 ↔ x = 0
tactic: haveI : Module.Free R S := Module.Free.of_basis b
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field F
inst✝⁴ : Algebra K L
inst✝³ : Algebra K F
ι : Type w
inst✝² : Finite ι
inst✝¹ : IsDomain R
inst✝ : IsDomain S
b : Basis ι R S
x : S
this : Module.Free R S
⊢ (norm R) x = 0 ↔ x = 0
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field F
inst✝⁴ : Algebra K L
inst✝³ : Algebra K F
ι : Type w
inst✝² : Finite ι
inst✝¹ : IsDomain R
inst✝ : IsDomain S
b : Basis ι R S
x : S
this✝ : Module.Free R S
this : Module.Finite R S
⊢ (norm R) x = 0 ↔ x = 0
tactic: haveI : Module.Finite R S := Module.Finite.of_basis b
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field F
inst✝⁴ : Algebra K L
inst✝³ : Algebra K F
ι : Type w
inst✝² : Finite ι
inst✝¹ : IsDomain R
inst✝ : IsDomain S
b : Basis ι R S
x : S
this✝ : Module.Free R S
this : Module.Finite R S
⊢ (norm R) x = 0 ↔ x = 0
state_after: no goals
tactic: exact norm_eq_zero_iff
Theorem: Pell.Solution₁.exists_pos_variant
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
h₀ : 0 < d
a : Solution₁ d
⊢ ∃ b, 0 < b.x ∧ 0 ≤ b.y ∧ a ∈ {b, b⁻¹, -b, -b⁻¹}
state_after: no goals
tactic: refine
        (lt_or_gt_of_ne (a.x_ne_zero h₀.le)).elim
          ((le_total 0 a.y).elim (fun hy hx => ⟨-a⁻¹, ?_, ?_, ?_⟩) fun hy hx => ⟨-a, ?_, ?_, ?_⟩)
          ((le_total 0 a.y).elim (fun hy hx => ⟨a, hx, hy, ?_⟩) fun hy hx => ⟨a⁻¹, hx, ?_, ?_⟩) <;>
      simp only [neg_neg, inv_inv, neg_inv, Set.mem_insert_iff, Set.mem_singleton_iff, true_or_iff,
        eq_self_iff_true, x_neg, x_inv, y_neg, y_inv, neg_pos, neg_nonneg, or_true_iff] <;>
    assumption
Theorem: FreeAddGroup.map.unique
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
⊢ ∀ {x : FreeGroup α}, g x = (map f) x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝ : FreeGroup α
L : List (α × Bool)
⊢ g (Quot.mk Red.Step L) = (map f) (Quot.mk Red.Step L)
tactic: rintro ⟨L⟩
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x y : FreeGroup α
g : FreeGroup α →* FreeGroup β
hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)
x✝ : FreeGroup α
L : List (α × Bool)
⊢ g (Quot.mk Red.Step L) = (map f) (Quot.mk Red.Step L)
state_after: no goals
tactic: exact List.recOn L g.map_one fun ⟨x, b⟩ t (ih : g (FreeGroup.mk t) = map f (FreeGroup.mk t)) =>
    Bool.recOn b
      (show g ((FreeGroup.of x)⁻¹ * FreeGroup.mk t) =
          FreeGroup.map f ((FreeGroup.of x)⁻¹ * FreeGroup.mk t) by
        simp [g.map_mul, g.map_inv, hg, ih])
      (show g (FreeGroup.of x * FreeGroup.mk t) =
          FreeGroup.map f (FreeGroup.of x * FreeGroup.mk t) by simp [g.map_mul, hg, ih])
Theorem: FreeAddSemigroup.length_add
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
x y : FreeSemigroup α
⊢ (x * y).length = x.length + y.length
state_after: no goals
tactic: simp [length, Nat.add_right_comm, List.length, List.length_append]
Theorem: mul_inv_le_one_iff_le
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a ≤ 1 * b ↔ a ≤ b
state_after: no goals
tactic: rw [one_mul]
Theorem: AffineEquiv.injective_pointReflection_left_of_module
File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

Proof steps:
state_before: k : Type u_1
P₁ : Type u_2
P₂ : Type u_3
P₃ : Type u_4
P₄ : Type u_5
V₁ : Type u_6
V₂ : Type u_7
V₃ : Type u_8
V₄ : Type u_9
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V₁
inst✝¹¹ : Module k V₁
inst✝¹⁰ : AffineSpace V₁ P₁
inst✝⁹ : AddCommGroup V₂
inst✝⁸ : Module k V₂
inst✝⁷ : AffineSpace V₂ P₂
inst✝⁶ : AddCommGroup V₃
inst✝⁵ : Module k V₃
inst✝⁴ : AffineSpace V₃ P₃
inst✝³ : AddCommGroup V₄
inst✝² : Module k V₄
inst✝¹ : AffineSpace V₄ P₄
inst✝ : Invertible 2
x y : V₁
h : (fun x => 2 • x) x = (fun x => 2 • x) y
⊢ x = y
state_after: k : Type u_1
P₁ : Type u_2
P₂ : Type u_3
P₃ : Type u_4
P₄ : Type u_5
V₁ : Type u_6
V₂ : Type u_7
V₃ : Type u_8
V₄ : Type u_9
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V₁
inst✝¹¹ : Module k V₁
inst✝¹⁰ : AffineSpace V₁ P₁
inst✝⁹ : AddCommGroup V₂
inst✝⁸ : Module k V₂
inst✝⁷ : AffineSpace V₂ P₂
inst✝⁶ : AddCommGroup V₃
inst✝⁵ : Module k V₃
inst✝⁴ : AffineSpace V₃ P₃
inst✝³ : AddCommGroup V₄
inst✝² : Module k V₄
inst✝¹ : AffineSpace V₄ P₄
inst✝ : Invertible 2
x y : V₁
h : 2 • x = 2 • y
⊢ x = y
tactic: dsimp at h
state_before: k : Type u_1
P₁ : Type u_2
P₂ : Type u_3
P₃ : Type u_4
P₄ : Type u_5
V₁ : Type u_6
V₂ : Type u_7
V₃ : Type u_8
V₄ : Type u_9
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V₁
inst✝¹¹ : Module k V₁
inst✝¹⁰ : AffineSpace V₁ P₁
inst✝⁹ : AddCommGroup V₂
inst✝⁸ : Module k V₂
inst✝⁷ : AffineSpace V₂ P₂
inst✝⁶ : AddCommGroup V₃
inst✝⁵ : Module k V₃
inst✝⁴ : AffineSpace V₃ P₃
inst✝³ : AddCommGroup V₄
inst✝² : Module k V₄
inst✝¹ : AffineSpace V₄ P₄
inst✝ : Invertible 2
x y : V₁
h : 2 • x = 2 • y
⊢ x = y
state_after: no goals
tactic: rwa [two_nsmul, two_nsmul, ← two_smul k x, ← two_smul k y,
      (isUnit_of_invertible (2 : k)).smul_left_cancel] at h
Theorem: IsBoundedLinearMap.tendsto
File: Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
e : E
⊢ ‖f e - f x‖ = ‖(IsLinearMap.mk' f hf) (e - x)‖
state_after: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
e : E
⊢ ‖f e - f x‖ = ‖(IsLinearMap.mk' f hf) e - (IsLinearMap.mk' f hf) x‖
tactic: rw [(hf.mk' _).map_sub e x]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
e : E
⊢ ‖f e - f x‖ = ‖(IsLinearMap.mk' f hf) e - (IsLinearMap.mk' f hf) x‖
state_after: no goals
tactic: rfl
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
x : E
hf✝ : IsBoundedLinearMap 𝕜 f
hf : IsLinearMap 𝕜 f
M : ℝ
left✝ : 0 < M
hM : ∀ (x : E), ‖f x‖ ≤ M * ‖x‖
this : Tendsto (fun e => M * ‖e - x‖) (𝓝 x) (𝓝 (M * 0))
⊢ Tendsto (fun e => M * ‖e - x‖) (𝓝 x) (𝓝 0)
state_after: no goals
tactic: simpa
Theorem: List.reverse_revzip
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List α
⊢ l.revzip.reverse = l.reverse.revzip
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List α
⊢ l.revzip.reverse.unzip.1.zip l.revzip.reverse.unzip.2 = l.reverse.revzip
tactic: rw [← zip_unzip (revzip l).reverse]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l : List α
⊢ l.revzip.reverse.unzip.1.zip l.revzip.reverse.unzip.2 = l.reverse.revzip
state_after: no goals
tactic: simp [unzip_eq_map, revzip, map_reverse, map_fst_zip, map_snd_zip]
Theorem: Finset.image₂_subset_iff_right
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ image₂ f s t ⊆ u ↔ ∀ b ∈ t, image (fun a => f a b) s ⊆ u
state_after: no goals
tactic: simp_rw [image₂_subset_iff, image_subset_iff, @forall₂_swap α]
Theorem: rank_fun'
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module R (φ i)
inst✝¹ : ∀ (i : η), Module.Free R (φ i)
inst✝ : Fintype η
⊢ Module.rank R (η → R) = ↑(Fintype.card η)
state_after: no goals
tactic: rw [rank_fun_eq_lift_mul, rank_self, Cardinal.lift_one, mul_one]
Theorem: MeasureTheory.Measure.outerMeasure_le_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : OuterMeasure α
⊢ m ≤ μ.toOuterMeasure ↔ ∀ (s : Set α), MeasurableSet s → m s ≤ μ s
state_after: no goals
tactic: simpa only [μ.trimmed] using OuterMeasure.le_trim_iff (m₂ := μ.1)
Theorem: WeierstrassCurve.Ψ_ofNat
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℕ
⊢ W.Ψ ↑n = C (W.preΨ' n) * if Even n then W.ψ₂ else 1
state_after: no goals
tactic: simp only [Ψ, preΨ_ofNat, Int.even_coe_nat]
Theorem: IsAlgClosed.splits_codomain
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

Proof steps:
state_before: k✝ : Type u
inst✝³ : Field k✝
k : Type u_1
K : Type u_2
inst✝² : Field k
inst✝¹ : IsAlgClosed k
inst✝ : Field K
f : K →+* k
p : K[X]
⊢ Splits f p
state_after: case a
k✝ : Type u
inst✝³ : Field k✝
k : Type u_1
K : Type u_2
inst✝² : Field k
inst✝¹ : IsAlgClosed k
inst✝ : Field K
f : K →+* k
p : K[X]
⊢ Splits f p ↔ Splits (RingHom.id k) (map f p)
tactic: convert IsAlgClosed.splits (p.map f)
state_before: case a
k✝ : Type u
inst✝³ : Field k✝
k : Type u_1
K : Type u_2
inst✝² : Field k
inst✝¹ : IsAlgClosed k
inst✝ : Field K
f : K →+* k
p : K[X]
⊢ Splits f p ↔ Splits (RingHom.id k) (map f p)
state_after: no goals
tactic: simp [splits_map_iff]