ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.Definable.map_expansion
File: Mathlib/ModelTheory/Definability.lean

Proof steps:
state_before: M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
L' : Language
inst✝¹ : L'.Structure M
h : A.Definable L s
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
⊢ A.Definable L' s
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ A.Definable L' (setOf ψ.Realize)
tactic: obtain ⟨ψ, rfl⟩ := h
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ A.Definable L' (setOf ψ.Realize)
state_after: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ setOf ψ.Realize = setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
tactic: refine ⟨(φ.addConstants A).onFormula ψ, ?_⟩
state_before: case intro
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
⊢ setOf ψ.Realize = setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
state_after: case intro.h
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
x : α → M
⊢ x ∈ setOf ψ.Realize ↔ x ∈ setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
tactic: ext x
state_before: case intro.h
M : Type w
A : Set M
L : Language
inst✝² : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
L' : Language
inst✝¹ : L'.Structure M
φ : L →ᴸ L'
inst✝ : φ.IsExpansionOn M
ψ : L[[↑A]].Formula α
x : α → M
⊢ x ∈ setOf ψ.Realize ↔ x ∈ setOf ((LHom.addConstants (↑A) φ).onFormula ψ).Realize
state_after: no goals
tactic: simp only [mem_setOf_eq, LHom.realize_onFormula]
Theorem: LaurentPolynomial.reduce_to_polynomial_of_mul_T
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
⊢ Q f
state_after: case Qf
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
⊢ Q (toLaurent f * T (-↑n))
tactic: induction' f using LaurentPolynomial.induction_on_mul_T with f n
state_before: case Qf
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
⊢ Q (toLaurent f * T (-↑n))
state_after: case Qf.zero
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
⊢ Q (toLaurent f * T (-↑0))

case Qf.succ
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
hn : Q (toLaurent f * T (-↑n))
⊢ Q (toLaurent f * T (-↑(n + 1)))
tactic: induction' n with n hn
Theorem: List.foldl_eq_foldr'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
hf : ∀ (a : α) (b c : β), f (f a b) c = f (f a c) b
a : α
b : β
l : List β
⊢ foldl f a (b :: l) = foldr (flip f) a (b :: l)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
hf : ∀ (a : α) (b c : β), f (f a b) c = f (f a c) b
a : α
b : β
l : List β
⊢ f (foldr (flip f) a l) b = flip f b (foldr (flip f) a l)
tactic: rw [foldl_eq_of_comm' hf, foldr, foldl_eq_foldr' ..]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → α
hf : ∀ (a : α) (b c : β), f (f a b) c = f (f a c) b
a : α
b : β
l : List β
⊢ f (foldr (flip f) a l) b = flip f b (foldr (flip f) a l)
state_after: no goals
tactic: rfl
Theorem: Filter.iSup_inf_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
⊢ ⨆ i, f i ⊓ 𝓟 s = (⨆ i, f i) ⊓ 𝓟 s
state_after: case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
s s✝ : Set α
⊢ s✝ ∈ ⨆ i, f i ⊓ 𝓟 s ↔ s✝ ∈ (⨆ i, f i) ⊓ 𝓟 s
tactic: ext
state_before: case h
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝¹ t : Set α
f : ι → Filter α
s s✝ : Set α
⊢ s✝ ∈ ⨆ i, f i ⊓ 𝓟 s ↔ s✝ ∈ (⨆ i, f i) ⊓ 𝓟 s
state_after: no goals
tactic: simp only [mem_iSup, mem_inf_principal]
Theorem: irrational_nat_div_iff
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑n / x) ↔ n ≠ 0 ∧ Irrational x
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: hasFTaylorSeriesUpToOn_succ_iff_right
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ HasFTaylorSeriesUpToOn (↑(n + 1)) f p s ↔
    (∀ x ∈ s, (p x 0).uncurry0 = f x) ∧
      (∀ x ∈ s, HasFDerivWithinAt (fun y => p y 0) (p x 1).curryLeft s x) ∧
        HasFTaylorSeriesUpToOn (↑n) (fun x => (continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) (fun x => (p x).shift) s
state_after: case mp
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ HasFTaylorSeriesUpToOn (↑(n + 1)) f p s →
    (∀ x ∈ s, (p x 0).uncurry0 = f x) ∧
      (∀ x ∈ s, HasFDerivWithinAt (fun y => p y 0) (p x 1).curryLeft s x) ∧
        HasFTaylorSeriesUpToOn (↑n) (fun x => (continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) (fun x => (p x).shift) s

case mpr
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ (∀ x ∈ s, (p x 0).uncurry0 = f x) ∧
      (∀ x ∈ s, HasFDerivWithinAt (fun y => p y 0) (p x 1).curryLeft s x) ∧
        HasFTaylorSeriesUpToOn (↑n) (fun x => (continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) (fun x => (p x).shift) s →
    HasFTaylorSeriesUpToOn (↑(n + 1)) f p s
tactic: constructor
Theorem: List.span_eq_take_drop
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ span p l = (takeWhile p l, dropWhile p l)
state_after: no goals
tactic: simpa using span.loop_eq_take_drop p l []
Theorem: SeminormedAddCommGroup.lipschitzWith_sub
File: Mathlib/Topology/Bornology/BoundedOperation.lean

Proof steps:
state_before: R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ LipschitzWith 2 fun p => p.1 - p.2
state_after: case h.e'_5
R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ 2 = 1 + 1
tactic: convert LipschitzWith.prod_fst.sub LipschitzWith.prod_snd
state_before: case h.e'_5
R : Type u_1
inst✝ : SeminormedAddCommGroup R
⊢ 2 = 1 + 1
state_after: no goals
tactic: norm_num
Theorem: Set.image_add_const_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) '' Iio b = Iio (b + a)
state_after: no goals
tactic: simp
Theorem: Matrix.fromColumns_mulVec_sum_elim
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m n₁ R
A₂ : Matrix m n₂ R
v₁ : n₁ → R
v₂ : n₂ → R
⊢ A₁.fromColumns A₂ *ᵥ Sum.elim v₁ v₂ = A₁ *ᵥ v₁ + A₂ *ᵥ v₂
state_after: case h
R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m n₁ R
A₂ : Matrix m n₂ R
v₁ : n₁ → R
v₂ : n₂ → R
x✝ : m
⊢ (A₁.fromColumns A₂ *ᵥ Sum.elim v₁ v₂) x✝ = (A₁ *ᵥ v₁ + A₂ *ᵥ v₂) x✝
tactic: ext
state_before: case h
R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
A₁ : Matrix m n₁ R
A₂ : Matrix m n₂ R
v₁ : n₁ → R
v₂ : n₂ → R
x✝ : m
⊢ (A₁.fromColumns A₂ *ᵥ Sum.elim v₁ v₂) x✝ = (A₁ *ᵥ v₁ + A₂ *ᵥ v₂) x✝
state_after: no goals
tactic: simp [Matrix.mulVec, fromColumns]
Theorem: MeasureTheory.exists_measurable_superset_forall_eq
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 α
inst✝ : Countable ι
μ : ι → Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i) s
state_after: no goals
tactic: simpa only [← measure_eq_trim] using
    OuterMeasure.exists_measurable_superset_forall_eq_trim (fun i => (μ i).toOuterMeasure) s
Theorem: SimpleGraph.TripartiteFromTriangles.toTriangle_apply
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 γ
x✝¹ x✝ : α × β × γ
a : α
b : β
c : γ
a' : α
b' : β
c' : γ
⊢ (fun x => {in₀ x.1, in₁ x.2.1, in₂ x.2.2}) (a, b, c) = (fun x => {in₀ x.1, in₁ x.2.1, in₂ x.2.2}) (a', b', c') →
    (a, b, c) = (a', b', c')
state_after: no goals
tactic: simpa only [Finset.Subset.antisymm_iff, Finset.subset_iff,
    mem_insert, mem_singleton, forall_eq_or_imp, forall_eq, Prod.mk.inj_iff, or_false, false_or,
    in₀, in₁, in₂, Sum.inl.inj_iff, Sum.inr.inj_iff] using And.left
Theorem: CategoryTheory.ShortComplex.abCyclesIso_inv_apply_iCycles
File: Mathlib/Algebra/Homology/ShortComplex/Ab.lean

Proof steps:
state_before: S : ShortComplex Ab
x : ↥(AddMonoidHom.ker S.g)
⊢ S.iCycles (S.abCyclesIso.inv x) = ↑x
state_after: S : ShortComplex Ab
x : ↥(AddMonoidHom.ker S.g)
⊢ S.iCycles (S.abLeftHomologyData.cyclesIso.inv x) = ↑x
tactic: dsimp only [abCyclesIso]
state_before: S : ShortComplex Ab
x : ↥(AddMonoidHom.ker S.g)
⊢ S.iCycles (S.abLeftHomologyData.cyclesIso.inv x) = ↑x
state_after: S : ShortComplex Ab
x : ↥(AddMonoidHom.ker S.g)
⊢ S.abLeftHomologyData.i x = ↑x
tactic: erw [← comp_apply, S.abLeftHomologyData.cyclesIso_inv_comp_iCycles]
state_before: S : ShortComplex Ab
x : ↥(AddMonoidHom.ker S.g)
⊢ S.abLeftHomologyData.i x = ↑x
state_after: no goals
tactic: rfl
Theorem: Subgroup.conj_smul_le_of_le
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Monoid α
inst✝ : MulDistribMulAction α G
P H : Subgroup G
hP : P ≤ H
h : ↥H
⊢ MulAut.conj ↑h • P ≤ H
state_after: case intro.intro
α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Monoid α
inst✝ : MulDistribMulAction α G
P H : Subgroup G
hP : P ≤ H
h : ↥H
g : G
hg : g ∈ ↑P
⊢ ((MulDistribMulAction.toMonoidEnd (MulAut G) G) (MulAut.conj ↑h)) g ∈ H
tactic: rintro - ⟨g, hg, rfl⟩
state_before: case intro.intro
α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Monoid α
inst✝ : MulDistribMulAction α G
P H : Subgroup G
hP : P ≤ H
h : ↥H
g : G
hg : g ∈ ↑P
⊢ ((MulDistribMulAction.toMonoidEnd (MulAut G) G) (MulAut.conj ↑h)) g ∈ H
state_after: no goals
tactic: exact H.mul_mem (H.mul_mem h.2 (hP hg)) (H.inv_mem h.2)
Theorem: summable_mul_right_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a ≠ 0
H : Summable fun i => f i * a
⊢ Summable f
state_after: no goals
tactic: simpa only [mul_inv_cancel_right₀ h] using H.mul_right a⁻¹
Theorem: AddOreLocalization.vadd_zero_vadd
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : R
x : OreLocalization S X
⊢ (r • 1) • x = r • x
state_after: case c
R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : R
r' : X
s : ↥S
⊢ (r • 1) • (r' /ₒ s) = r • (r' /ₒ s)
tactic: induction' x using OreLocalization.ind with r' s
state_before: case c
R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : R
r' : X
s : ↥S
⊢ (r • 1) • (r' /ₒ s) = r • (r' /ₒ s)
state_after: no goals
tactic: simp only [smul_oreDiv, smul_eq_mul, mul_one]
Theorem: AddAction.isPeriodicPt_vadd_iff
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
m : M
a : α
n : ℕ
⊢ IsPeriodicPt (fun x => m • x) n a ↔ m ^ n • a = a
state_after: no goals
tactic: rw [← smul_iterate_apply, IsPeriodicPt, IsFixedPt]
Theorem: add_pow_char_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x + y) ^ p = x ^ p + y ^ p
state_after: R : Type u_1
inst✝¹ : Semiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p = x ^ p + y ^ p + ↑p * r
⊢ (x + y) ^ p = x ^ p + y ^ p
tactic: let ⟨r, hr⟩ := h.exists_add_pow_prime_eq hp.out
state_before: R : Type u_1
inst✝¹ : Semiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p = x ^ p + y ^ p + ↑p * r
⊢ (x + y) ^ p = x ^ p + y ^ p
state_after: no goals
tactic: simp [hr]
Theorem: circleIntegrable_sub_inv_iff
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
⊢ CircleIntegrable (fun z => (z - w)⁻¹) c R ↔ R = 0 ∨ w ∉ sphere c |R|
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
⊢ R = 0 ∨ 0 ≤ -1 ∨ w ∉ sphere c |R| ↔ R = 0 ∨ w ∉ sphere c |R|
tactic: simp only [← zpow_neg_one, circleIntegrable_sub_zpow_iff]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
⊢ R = 0 ∨ 0 ≤ -1 ∨ w ∉ sphere c |R| ↔ R = 0 ∨ w ∉ sphere c |R|
state_after: no goals
tactic: norm_num
Theorem: MeasureTheory.hasFiniteIntegral_count_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : MeasurableSingletonClass α
f : α → β
⊢ HasFiniteIntegral f Measure.count ↔ Summable fun x => ‖f x‖
state_after: no goals
tactic: simp only [HasFiniteIntegral, lintegral_count, lt_top_iff_ne_top,
    ENNReal.tsum_coe_ne_top_iff_summable,  ← NNReal.summable_coe, coe_nnnorm]
Theorem: imageToKernel_op
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : Category.{?u.28, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.op ≫ f.op = 0
state_after: no goals
tactic: rw [← op_comp, w, op_zero]
state_before: V : Type u_1
inst✝¹ : Category.{?u.28, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0
state_after: no goals
tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ =
    (imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ ≫ (kernelSubobject f.op).arrow =
    ((imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv) ≫
      (kernelSubobject f.op).arrow
tactic: ext
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op ⋯ ≫ (kernelSubobject f.op).arrow =
    ((imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).op ≫ (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv) ≫
      (kernelSubobject f.op).arrow
state_after: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (imageSubobjectIso g.op).hom ≫ (imageUnopOp g.op).inv ≫ (factorThruImage g.op.unop).op =
    (imageSubobjectIso g.op).hom ≫ (imageOpOp g).inv ≫ (factorThruImage g).op
tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelOpOp_inv, Category.assoc,
    imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, ← op_comp, cokernel.π_desc,
    ← imageSubobject_arrow, ← imageUnopOp_inv_comp_op_factorThruImage g.op]
state_before: case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (imageSubobjectIso g.op).hom ≫ (imageUnopOp g.op).inv ≫ (factorThruImage g.op.unop).op =
    (imageSubobjectIso g.op).hom ≫ (imageOpOp g).inv ≫ (factorThruImage g).op
state_after: no goals
tactic: rfl
Theorem: SetTheory.PGame.lf_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ y ⧏ -x ↔ x ⧏ -y
state_after: no goals
tactic: rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
Theorem: Algebra.traceMatrix_of_matrix_mulVec
File: Mathlib/RingTheory/Trace/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁹ : CommRing R
inst✝¹⁸ : CommRing S
inst✝¹⁷ : CommRing T
inst✝¹⁶ : Algebra R S
inst✝¹⁵ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹⁴ : Field K
inst✝¹³ : Field L
inst✝¹² : Algebra K L
ι κ : Type w
inst✝¹¹ : Fintype ι
F : Type u_6
inst✝¹⁰ : Field F
inst✝⁹ : Algebra R L
inst✝⁸ : Algebra L F
inst✝⁷ : Algebra R F
inst✝⁶ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : CommRing C
inst✝¹ : Algebra A C
inst✝ : Fintype κ
b : κ → B
P : Matrix κ κ A
⊢ traceMatrix A (P.map ⇑(algebraMap A B) *ᵥ b) = P * traceMatrix A b * Pᵀ
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁹ : CommRing R
inst✝¹⁸ : CommRing S
inst✝¹⁷ : CommRing T
inst✝¹⁶ : Algebra R S
inst✝¹⁵ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹⁴ : Field K
inst✝¹³ : Field L
inst✝¹² : Algebra K L
ι κ : Type w
inst✝¹¹ : Fintype ι
F : Type u_6
inst✝¹⁰ : Field F
inst✝⁹ : Algebra R L
inst✝⁸ : Algebra L F
inst✝⁷ : Algebra R F
inst✝⁶ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : CommRing C
inst✝¹ : Algebra A C
inst✝ : Fintype κ
b : κ → B
P : Matrix κ κ A
⊢ (transposeAddEquiv κ κ A) (traceMatrix A (P.map ⇑(algebraMap A B) *ᵥ b)) =
    (transposeAddEquiv κ κ A) (P * traceMatrix A b * Pᵀ)
tactic: refine AddEquiv.injective (transposeAddEquiv κ κ A) ?_
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁹ : CommRing R
inst✝¹⁸ : CommRing S
inst✝¹⁷ : CommRing T
inst✝¹⁶ : Algebra R S
inst✝¹⁵ : Algebra R T
K : Type u_4
L : Type u_5
inst✝¹⁴ : Field K
inst✝¹³ : Field L
inst✝¹² : Algebra K L
ι κ : Type w
inst✝¹¹ : Fintype ι
F : Type u_6
inst✝¹⁰ : Field F
inst✝⁹ : Algebra R L
inst✝⁸ : Algebra L F
inst✝⁷ : Algebra R F
inst✝⁶ : IsScalarTower R L F
A : Type u
B : Type v
C : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : CommRing C
inst✝¹ : Algebra A C
inst✝ : Fintype κ
b : κ → B
P : Matrix κ κ A
⊢ (transposeAddEquiv κ κ A) (traceMatrix A (P.map ⇑(algebraMap A B) *ᵥ b)) =
    (transposeAddEquiv κ κ A) (P * traceMatrix A b * Pᵀ)
state_after: no goals
tactic: rw [transposeAddEquiv_apply, transposeAddEquiv_apply, ← vecMul_transpose, ← transpose_map,
    traceMatrix_of_matrix_vecMul, transpose_transpose]
Theorem: HomologicalComplex.singleObjCyclesSelfIso_inv_iCycles
File: Mathlib/Algebra/Homology/SingleHomology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : C
⊢ (singleObjCyclesSelfIso c j A).inv ≫ ((single C c j).obj A).iCycles j = (singleObjXSelf c j A).inv
state_after: no goals
tactic: simp [singleObjCyclesSelfIso]
Theorem: ArithmeticFunction.moebius_apply_prime
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
p : ℕ
hp : Nat.Prime p
⊢ μ p = -1
state_after: no goals
tactic: rw [moebius_apply_of_squarefree hp.squarefree, cardFactors_apply_prime hp, pow_one]
Theorem: Set.sep_eq_self_iff_mem_true
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
p q : α → Prop
x : α
⊢ {x | x ∈ s ∧ p x} = s ↔ ∀ x ∈ s, p x
state_after: no goals
tactic: simp_rw [Set.ext_iff, mem_sep_iff, and_iff_left_iff_imp]