1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.div_mem_centralizer
File: Mathlib/Algebra/Group/Centralizer.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Group M
ha : a ∈ S.centralizer
hb : b ∈ S.centralizer
⊢ a / b ∈ S.centralizer
state_after: M : Type u_1
S T : Set M
a b : M
inst✝ : Group M
ha : a ∈ S.centralizer
hb : b ∈ S.centralizer
⊢ a * b⁻¹ ∈ S.centralizer

tactic: exact mul_mem_centralizer ha (inv_mem_centralizer hb)
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Group M
ha : a ∈ S.centralizer
hb : b ∈ S.centralizer
⊢ a * b⁻¹ ∈ S.centralizer
state_after: no goals
Theorem: Submodule.mkQ_surjective
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rintro ⟨x⟩
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p p' : Submodule R M
M₂ : Type u_3
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
A : Submodule R M
⊢ Function.Surjective ⇑A.mkQ
state_after: case mk
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p p' : Submodule R M
M₂ : Type u_3
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
A : Submodule R M
b✝ : M ⧸ A
x : M
⊢ ∃ a, A.mkQ a = Quot.mk Setoid.r x

tactic: exact ⟨x, rfl⟩
state_before: case mk
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p p' : Submodule R M
M₂ : Type u_3
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
A : Submodule R M
b✝ : M ⧸ A
x : M
⊢ ∃ a, A.mkQ a = Quot.mk Setoid.r x
state_after: no goals
Theorem: Codisjoint.ne_bot_of_ne_top
File: Mathlib/Order/Disjoint.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : BoundedOrder α
a b : α
h : Codisjoint a b
ha : a ≠ ⊤
⊢ b ≠ ⊥
state_after: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : BoundedOrder α
a : α
ha : a ≠ ⊤
h : Codisjoint a ⊥
⊢ False

tactic: exact ha <| by simpa using h
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : BoundedOrder α
a : α
ha : a ≠ ⊤
h : Codisjoint a ⊥
⊢ False
state_after: no goals

tactic: simpa using h
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : BoundedOrder α
a : α
ha : a ≠ ⊤
h : Codisjoint a ⊥
⊢ a = ⊤
state_after: no goals
Theorem: Inducing.continuousWithinAt_iff
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp_rw [ContinuousWithinAt, Inducing.tendsto_nhds_iff hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ ContinuousWithinAt f s x ↔ ContinuousWithinAt (g ∘ f) s x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 (g (f x))) ↔ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 ((g ∘ f) x))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hg : Inducing g
s : Set α
x : α
⊢ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 (g (f x))) ↔ Tendsto (g ∘ f) (𝓝[s] x) (𝓝 ((g ∘ f) x))
state_after: no goals
Theorem: IsCompact.elim_finite_subcover_image
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simp only [Subtype.forall', biUnion_eq_iUnion] at hc₁ hc₂
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ i ∈ b, IsOpen (c i)
hc₂ : s ⊆ ⋃ i ∈ b, c i
⊢ ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
⊢ ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i

tactic: rcases hs.elim_finite_subcover (fun i => c i : b → Set X) hc₁ hc₂ with ⟨d, hd⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
⊢ ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i
state_after: case intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i

tactic: refine ⟨Subtype.val '' d.toSet, ?_, d.finite_toSet.image _, ?_⟩
state_before: case intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ ∃ b' ⊆ b, b'.Finite ∧ s ⊆ ⋃ i ∈ b', c i
state_after: case intro.refine_1
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ Subtype.val '' ↑d ⊆ b

case intro.refine_2
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ s ⊆ ⋃ i ∈ Subtype.val '' ↑d, c i

tactic: simp
state_before: case intro.refine_1
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ Subtype.val '' ↑d ⊆ b
state_after: no goals

tactic: rwa [biUnion_image]
state_before: case intro.refine_2
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
b : Set ι
c : ι → Set X
hs : IsCompact s
hc₁ : ∀ (x : { a // a ∈ b }), IsOpen (c ↑x)
hc₂ : s ⊆ ⋃ x, c ↑x
d : Finset ↑b
hd : s ⊆ ⋃ i ∈ d, c ↑i
⊢ s ⊆ ⋃ i ∈ Subtype.val '' ↑d, c i
state_after: no goals
Theorem: Multiset.mem_Ici
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ici, ← Finset.mem_def, Finset.mem_Ici]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrderTop α
a x : α
⊢ x ∈ Ici a ↔ a ≤ x
state_after: no goals
Theorem: Finset.union_right_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_union, or_assoc, @or_comm (x ∈ t)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ v : Finset α
a b : α
s t u : Finset α
x : α
⊢ x ∈ s ∪ t ∪ u ↔ x ∈ s ∪ u ∪ t
state_after: no goals
Theorem: UniformOnFun.uniformContinuous_ofUniformFun
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp only [UniformContinuous, UniformOnFun.uniformity_eq, tendsto_iInf, tendsto_principal,
  (UniformFun.hasBasis_uniformity _ _).eventually_iff]
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 α)
⊢ UniformContinuous fun f => (ofFun 𝔖) (UniformFun.toFun 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 α)
⊢ ∀ i ∈ 𝔖,
    ∀ i_2 ∈ 𝓤 β,
      ∃ i_4 ∈ 𝓤 β,
        ∀ ⦃x : (α →ᵤ β) × (α →ᵤ β)⦄,
          x ∈ UniformFun.gen α β i_4 →
            ((ofFun 𝔖) (UniformFun.toFun x.1), (ofFun 𝔖) (UniformFun.toFun x.2)) ∈ UniformOnFun.gen 𝔖 i i_2

tactic: exact fun _ _ U hU ↦ ⟨U, hU, fun f hf x _ ↦ hf x⟩
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 α)
⊢ ∀ i ∈ 𝔖,
    ∀ i_2 ∈ 𝓤 β,
      ∃ i_4 ∈ 𝓤 β,
        ∀ ⦃x : (α →ᵤ β) × (α →ᵤ β)⦄,
          x ∈ UniformFun.gen α β i_4 →
            ((ofFun 𝔖) (UniformFun.toFun x.1), (ofFun 𝔖) (UniformFun.toFun x.2)) ∈ UniformOnFun.gen 𝔖 i i_2
state_after: no goals
Theorem: Ideal.IsHomogeneous.mem_iff
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: classical
refine ⟨fun hx i ↦ hI i hx, fun hx ↦ ?_⟩
rw [← DirectSum.sum_support_decompose 𝒜 x]
exact Ideal.sum_mem _ (fun i _ ↦ hx i)
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
⊢ x ∈ I ↔ ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
state_after: no goals

tactic: refine ⟨fun hx i ↦ hI i hx, fun hx ↦ ?_⟩
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
⊢ x ∈ I ↔ ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
state_after: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
hx : ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
⊢ x ∈ I

tactic: rw [← DirectSum.sum_support_decompose 𝒜 x]
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
hx : ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
⊢ x ∈ I
state_after: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
hx : ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
⊢ ∑ i ∈ DFinsupp.support ((decompose 𝒜) x), ↑(((decompose 𝒜) x) i) ∈ I

tactic: exact Ideal.sum_mem _ (fun i _ ↦ hx i)
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I✝ I : Ideal A
hI : IsHomogeneous 𝒜 I
x : A
hx : ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I
⊢ ∑ i ∈ DFinsupp.support ((decompose 𝒜) x), ↑(((decompose 𝒜) x) i) ∈ I
state_after: no goals
Theorem: Nat.card_prod
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simp only [Nat.card, mk_prod, toNat_mul, toNat_lift]
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u_3
β : Type u_4
⊢ Nat.card (α × β) = Nat.card α * Nat.card β
state_after: no goals
Theorem: Set.Icc_union_Icc
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rcases le_or_lt a b with hab | hab <;> rcases le_or_lt c d with hcd | hcd <;>
  simp only [min_eq_left, min_eq_right, max_eq_left, max_eq_right, min_eq_left_of_lt,
    min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt, hab, hcd] at h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : min a b < max c d
h₂ : min c d < max a b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)
state_after: case inl.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inl.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d < c
h₁ : a < c
h₂ : d < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : d < c
h₁ : b < c
h₂ : d < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

tactic: all_goals simp [*, min_eq_left_of_lt, max_eq_left_of_lt, min_eq_right_of_lt, max_eq_right_of_lt]
state_before: case inl.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d < c
h₁ : a < c
h₂ : d < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : d < c
h₁ : b < c
h₂ : d < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)
state_after: no goals

tactic: exact Icc_union_Icc' h₂.le h₁.le
state_before: case inl.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)
state_after: no goals

tactic: simp [*, min_eq_left_of_lt, max_eq_left_of_lt, min_eq_right_of_lt, max_eq_right_of_lt]
state_before: case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : d < c
h₁ : b < c
h₂ : d < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)
state_after: no goals
Theorem: finRotate_of_lt
File: Mathlib/Logic/Equiv/Fin.lean

tactic: ext
state_before: m n k : ℕ
h : k < n
⊢ (finRotate (n + 1)) ⟨k, ⋯⟩ = ⟨k + 1, ⋯⟩
state_after: case h
m n k : ℕ
h : k < n
⊢ ↑((finRotate (n + 1)) ⟨k, ⋯⟩) = ↑⟨k + 1, ⋯⟩

tactic: dsimp [finRotate_succ]
state_before: case h
m n k : ℕ
h : k < n
⊢ ↑((finRotate (n + 1)) ⟨k, ⋯⟩) = ↑⟨k + 1, ⋯⟩
state_after: case h
m n k : ℕ
h : k < n
⊢ ↑(finAddFlip ⟨k, ⋯⟩) = k + 1

tactic: simp [finAddFlip_apply_mk_left h, Nat.add_comm]
state_before: case h
m n k : ℕ
h : k < n
⊢ ↑(finAddFlip ⟨k, ⋯⟩) = k + 1
state_after: no goals
Theorem: multiplicity.Int.natAbs
File: Mathlib/RingTheory/Multiplicity.lean

tactic: cases' Int.natAbs_eq b with h h <;> conv_rhs => rw [h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
⊢ multiplicity a b.natAbs = multiplicity (↑a) b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = ↑b.natAbs
⊢ multiplicity a b.natAbs = multiplicity ↑a ↑b.natAbs

case inr
α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = -↑b.natAbs
⊢ multiplicity a b.natAbs = multiplicity (↑a) (-↑b.natAbs)

tactic: rw [Int.natCast_multiplicity]
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = ↑b.natAbs
⊢ multiplicity a b.natAbs = multiplicity ↑a ↑b.natAbs
state_after: no goals

tactic: rw [multiplicity.neg, Int.natCast_multiplicity]
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : ℕ
b : ℤ
h : b = -↑b.natAbs
⊢ multiplicity a b.natAbs = multiplicity (↑a) (-↑b.natAbs)
state_after: no goals
Theorem: Set.Finite.surjOn_iff_bijOn_of_mapsTo
File: Mathlib/Data/Set/Finite.lean

tactic: refine ⟨fun h ↦ ⟨hm, ?_, h⟩, BijOn.surjOn⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
⊢ SurjOn f s s ↔ BijOn f s s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
⊢ InjOn f s

tactic: have : Finite s := finite_coe_iff.mpr hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
⊢ InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
this : Finite ↑s
⊢ InjOn f s

tactic: exact hm.restrict_inj.mp (Finite.injective_iff_surjective.mpr <| hm.restrict_surjective_iff.mpr h)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
this : Finite ↑s
⊢ InjOn f s
state_after: no goals
Theorem: PowerSeries.invUnitsSub_mul_sub
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: simp [mul_sub, sub_sub_cancel]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
⊢ invUnitsSub u * ((C R) ↑u - X) = 1
state_after: no goals
Theorem: EisensteinSeries.eisensteinSeries_SIF_MDifferentiable
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/MDifferentiable.lean

tactic: intro τ
state_before: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
⊢ MDifferentiable 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) ⇑(eisensteinSeries_SIF a k)
state_after: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ MDifferentiableAt 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) (⇑(eisensteinSeries_SIF a k)) τ

tactic: suffices DifferentiableAt ℂ (↑ₕeisensteinSeries_SIF a k) τ.1 by
  convert MDifferentiableAt.comp τ (DifferentiableAt.mdifferentiableAt this) τ.mdifferentiable_coe
  exact funext fun z ↦ (comp_ofComplex (eisensteinSeries_SIF a k) z).symm
state_before: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ MDifferentiableAt 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) (⇑(eisensteinSeries_SIF a k)) τ
state_after: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ DifferentiableAt ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ↑τ

tactic: refine DifferentiableOn.differentiableAt ?_
  ((isOpen_lt continuous_const Complex.continuous_im).mem_nhds τ.2)
state_before: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ DifferentiableAt ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ↑τ
state_after: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ DifferentiableOn ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) {b | 0 < b.im}

tactic: exact (eisensteinSeries_tendstoLocallyUniformlyOn hk a).differentiableOn
  (eventually_of_forall fun s ↦ DifferentiableOn.sum
    fun _ _ ↦ eisSummand_extension_differentiableOn _ _)
      (isOpen_lt continuous_const continuous_im)
state_before: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
⊢ DifferentiableOn ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) {b | 0 < b.im}
state_after: no goals

tactic: convert MDifferentiableAt.comp τ (DifferentiableAt.mdifferentiableAt this) τ.mdifferentiable_coe
state_before: k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
this : DifferentiableAt ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ↑τ
⊢ MDifferentiableAt 𝓘(ℂ, ℂ) 𝓘(ℂ, ℂ) (⇑(eisensteinSeries_SIF a k)) τ
state_after: case h.e'_21
k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
this : DifferentiableAt ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ↑τ
⊢ ⇑(eisensteinSeries_SIF a k) = (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ∘ Subtype.val

tactic: exact funext fun z ↦ (comp_ofComplex (eisensteinSeries_SIF a k) z).symm
state_before: case h.e'_21
k : ℤ
N : ℕ
hk : 3 ≤ k
a : Fin 2 → ZMod N
τ : ℍ
this : DifferentiableAt ℂ (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ↑τ
⊢ ⇑(eisensteinSeries_SIF a k) = (⇑(eisensteinSeries_SIF a k) ∘ ↑ofComplex) ∘ Subtype.val
state_after: no goals
Theorem: CategoryTheory.Abelian.mono_of_epi_of_epi_of_mono
File: Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean

tactic: simpa only [map'_comp R₁ 0 1 2] using hR₁.toIsComplex.zero 0
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 2
φ : R₁ ⟶ R₂
hR₁ : R₁.Exact
hR₂ : R₂.Exact
hR₁' : Epi (R₁.map' 1 2 ⋯ ⋯)
h₀ : Epi (app' φ 0 ⋯)
h₁ : Mono (app' φ 1 ⋯)
⊢ R₁.map' 0 2 ⋯ ⋯ = 0
state_after: no goals
Theorem: List.dedup_eq_nil
File: Mathlib/Data/List/Dedup.lean

tactic: induction' l with a l hl
state_before: α : Type u
inst✝ : DecidableEq α
l : List α
⊢ l.dedup = [] ↔ l = []
state_after: case nil
α : Type u
inst✝ : DecidableEq α
⊢ [].dedup = [] ↔ [] = []

case cons
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
⊢ (a :: l).dedup = [] ↔ a :: l = []

tactic: exact Iff.rfl
state_before: case nil
α : Type u
inst✝ : DecidableEq α
⊢ [].dedup = [] ↔ [] = []
state_after: no goals

tactic: by_cases h : a ∈ l
state_before: case cons
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
⊢ (a :: l).dedup = [] ↔ a :: l = []
state_after: case pos
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
h : a ∈ l
⊢ (a :: l).dedup = [] ↔ a :: l = []

case neg
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
h : a ∉ l
⊢ (a :: l).dedup = [] ↔ a :: l = []

tactic: simp only [List.dedup_cons_of_mem h, hl, List.ne_nil_of_mem h]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
h : a ∈ l
⊢ (a :: l).dedup = [] ↔ a :: l = []
state_after: no goals

tactic: simp only [List.dedup_cons_of_not_mem h, List.cons_ne_nil]
state_before: case neg
α : Type u
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
h : a ∉ l
⊢ (a :: l).dedup = [] ↔ a :: l = []
state_after: no goals
Theorem: pow_add
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [Nat.add_zero, pow_zero, mul_one]
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m✝ n : ℕ
a : M
m : ℕ
⊢ a ^ (m + 0) = a ^ m * a ^ 0
state_after: no goals

tactic: rw [pow_succ, ← mul_assoc, ← pow_add, ← pow_succ, Nat.add_assoc]
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m✝ n✝ : ℕ
a : M
m n : ℕ
⊢ a ^ (m + (n + 1)) = a ^ m * a ^ (n + 1)
state_after: no goals
Theorem: Module.End.IsSemisimple.genEigenspace_eq_eigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean

tactic: refine le_antisymm (fun m hm ↦ mem_eigenspace_iff.mpr ?_) (eigenspace_le_genEigenspace hk)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
⊢ (f.genEigenspace μ) k = f.eigenspace μ
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
m : M
hm : m ∈ (f.genEigenspace μ) k
⊢ f m = μ • m

tactic: exact apply_eq_of_mem_genEigenspace_of_comm_of_isSemisimple_of_isNilpotent_sub hm rfl hf (by simp)
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
m : M
hm : m ∈ (f.genEigenspace μ) k
⊢ f m = μ • m
state_after: no goals

tactic: simp
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f g : End R M
hf : f.IsSemisimple
μ : R
k : ℕ
hk : 0 < k
m : M
hm : m ∈ (f.genEigenspace μ) k
⊢ IsNilpotent (f - f)
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable.comp_snd_map_prod_id
File: Mathlib/Probability/Kernel/Condexp.lean

tactic: rw [← aestronglyMeasurable_comp_snd_map_prod_mk_iff (measurable_id'' hm)] at hf
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)

tactic: simp_rw [id] at hf ⊢
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)

tactic: exact hf
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
state_after: no goals