ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y : α
inst✝² : DecidableRel f.SameCycle
inst✝¹ : DecidableRel g.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
⊢ (f * g).cycleOf x = f.cycleOf x
state_after: case H
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f.SameCycle
inst✝¹ : DecidableRel g.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
y : α
⊢ ((f * g).cycleOf x) y = (f.cycleOf x) y
tactic: ext y
state_before: case H
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f.SameCycle
inst✝¹ : DecidableRel g.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
y : α
⊢ ((f * g).cycleOf x) y = (f.cycleOf x) y
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f.SameCycle
inst✝¹ : DecidableRel g.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
y : α
hxy : (f * g).SameCycle x y
⊢ ((f * g).cycleOf x) y = (f.cycleOf x) y

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x✝ y✝ : α
inst✝² : DecidableRel f.SameCycle
inst✝¹ : DecidableRel g.SameCycle
inst✝ : DecidableRel (f * g).SameCycle
h : Commute f g
x : α
hx : g x = x
y : α
hxy : ¬(f * g).SameCycle x y
⊢ ((f * g).cycleOf x) y = (f.cycleOf x) y
tactic: by_cases hxy : (f * g).SameCycle x y
Theorem: div_div_div_eq
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b / (c / d) = a * d / (b * c)
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.indepFun_iff_measure_inter_preimage_eq_mul
File: Mathlib/Probability/Independence/Kernel.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
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f : Ω → β
g : Ω → β'
mβ : MeasurableSpace β
mβ' : MeasurableSpace β'
⊢ IndepFun f g κ μ ↔
    ∀ (s : Set β) (t : Set β'),
      MeasurableSet s → MeasurableSet t → ∀ᵐ (a : α) ∂μ, (κ a) (f ⁻¹' s ∩ g ⁻¹' t) = (κ a) (f ⁻¹' s) * (κ a) (g ⁻¹' t)
state_after: case mp
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f : Ω → β
g : Ω → β'
mβ : MeasurableSpace β
mβ' : MeasurableSpace β'
h : IndepFun f g κ μ
⊢ ∀ (s : Set β) (t : Set β'),
    MeasurableSet s → MeasurableSet t → ∀ᵐ (a : α) ∂μ, (κ a) (f ⁻¹' s ∩ g ⁻¹' t) = (κ a) (f ⁻¹' s) * (κ a) (g ⁻¹' t)

case mpr
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f : Ω → β
g : Ω → β'
mβ : MeasurableSpace β
mβ' : MeasurableSpace β'
h :
  ∀ (s : Set β) (t : Set β'),
    MeasurableSet s → MeasurableSet t → ∀ᵐ (a : α) ∂μ, (κ a) (f ⁻¹' s ∩ g ⁻¹' t) = (κ a) (f ⁻¹' s) * (κ a) (g ⁻¹' t)
⊢ IndepFun f g κ μ
tactic: constructor <;> intro h
Theorem: CategoryTheory.ComposableArrows.homMk₅_app_two
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.414921, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 5
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ⟶ g.obj' 4 ⋯
app₅ : f.obj' 5 ⋯ ⟶ g.obj' 5 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄ = app₃ ≫ g.map' 3 4 ⋯ ⋯
w₄ : f.map' 4 5 ⋯ ⋯ ≫ app₅ = app₄ ≫ g.map' 4 5 ⋯ ⋯
⊢ 2 < 5 + 1
state_after: no goals
tactic: valid
Theorem: Finset.subtype_eq_univ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Fintype α
s t : Finset α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype { a // p a }
⊢ Finset.subtype p s = univ ↔ ∀ ⦃a : α⦄, p a → a ∈ s
state_after: no goals
tactic: simp [ext_iff]
Theorem: IsPurelyInseparable.sepDegree_eq_one
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsPurelyInseparable F E
⊢ sepDegree F E = 1
state_after: no goals
tactic: rw [sepDegree, separableClosure.eq_bot_of_isPurelyInseparable, IntermediateField.rank_bot]
Theorem: Nat.factorization_eq_primeFactorsList_multiset
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n✝ p n : ℕ
⊢ n.factorization = Multiset.toFinsupp ↑n.primeFactorsList
state_after: case h
a b m n✝ p✝ n p : ℕ
⊢ n.factorization p = (Multiset.toFinsupp ↑n.primeFactorsList) p
tactic: ext p
state_before: case h
a b m n✝ p✝ n p : ℕ
⊢ n.factorization p = (Multiset.toFinsupp ↑n.primeFactorsList) p
state_after: no goals
tactic: simp
Theorem: Finset.map_refl
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α ↪ β
s : Finset α
x✝ : α
⊢ x✝ ∈ map (Embedding.refl α) s ↔ x✝ ∈ s
state_after: no goals
tactic: simpa only [mem_map, exists_prop] using exists_eq_right
Theorem: Valued.hasBasis_uniformity
File: Mathlib/Topology/Algebra/Valued/ValuationTopology.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ (uniformity R).HasBasis (fun x => True) fun γ => {p | v (p.2 - p.1) < ↑γ}
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ (Filter.comap (fun x => x.2 - x.1) (𝓝 0)).HasBasis (fun x => True) fun γ => {p | v (p.2 - p.1) < ↑γ}
tactic: rw [uniformity_eq_comap_nhds_zero]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ (Filter.comap (fun x => x.2 - x.1) (𝓝 0)).HasBasis (fun x => True) fun γ => {p | v (p.2 - p.1) < ↑γ}
state_after: no goals
tactic: exact (hasBasis_nhds_zero R Γ₀).comap _
Theorem: reflection_sub
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
⊢ (reflection (Submodule.span ℝ {v - w})ᗮ) v = w
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
⊢ R v = w
tactic: set R : F ≃ₗᵢ[ℝ] F := reflection (ℝ ∙ v - w)ᗮ
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
⊢ R v = w
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
⊢ R v + R v = w + w
tactic: suffices R v + R v = w + w by
    apply smul_right_injective F (by norm_num : (2 : ℝ) ≠ 0)
    simpa [two_smul] using this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
⊢ R v + R v = w + w
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
h₁ : R (v - w) = -(v - w)
⊢ R v + R v = w + w
tactic: have h₁ : R (v - w) = -(v - w) := reflection_orthogonalComplement_singleton_eq_neg (v - w)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
h₁ : R (v - w) = -(v - w)
⊢ R v + R v = w + w
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v w : F
h : ‖v‖ = ‖w‖
R : F ≃ₗᵢ[ℝ] F := reflection (Submodule.span ℝ {v - w})ᗮ
h₁ : R (v - w) = -(v - w)
h₂ : R (v + w) = v + w
⊢ R v + R v = w + w
tactic: have h₂ : R (v + w) = v + w := by
    apply reflection_mem_subspace_eq_self
    rw [Submodule.mem_orthogonal_singleton_iff_inner_left]
    rw [real_inner_add_sub_eq_zero_iff]
    exact h
Theorem: Cardinal.nat_lt_lift_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
n : ℕ
a : Cardinal.{u}
⊢ ↑n < lift.{v, u} a ↔ ↑n < a
state_after: no goals
tactic: rw [← lift_natCast.{v,u}, lift_lt]
Theorem: Substring.Valid.next_stop
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.next { byteIdx := x✝.bsize } = { byteIdx := x✝.bsize }
state_after: no goals
tactic: simp [h.bsize, h.next_stop]
Theorem: MeasureTheory.Measure.Regular.map
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
⊢ (map (⇑f) μ).Regular
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this : (map (⇑f) μ).OuterRegular
⊢ (map (⇑f) μ).Regular
tactic: haveI := OuterRegular.map f μ
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this : (map (⇑f) μ).OuterRegular
⊢ (map (⇑f) μ).Regular
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this✝ : (map (⇑f) μ).OuterRegular
this : IsFiniteMeasureOnCompacts (map (⇑f) μ)
⊢ (map (⇑f) μ).Regular
tactic: haveI := IsFiniteMeasureOnCompacts.map μ f
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this✝ : (map (⇑f) μ).OuterRegular
this : IsFiniteMeasureOnCompacts (map (⇑f) μ)
⊢ (map (⇑f) μ).Regular
state_after: no goals
tactic: exact
    ⟨Regular.innerRegular.map' f.toMeasurableEquiv
        (fun U hU => hU.preimage f.continuous)
        (fun K hK => hK.image f.continuous)⟩
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_of_le
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
⊢ X.σ j.succ ≫ X.δ i.castSucc = X.δ i ≫ X.σ j
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.σ j.succ).op ≫ X.map (SimplexCategory.δ i.castSucc).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.σ j.succ).op ≫ X.map (SimplexCategory.δ i.castSucc).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_le H]
Theorem: List.fillNones_eq_fillNonesTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @fillNones = @fillNonesTR
state_after: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = as.fillNonesTR as'
tactic: funext α as as'
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = as.fillNonesTR as'
state_after: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = fillNonesTR.go as as' #[]
tactic: simp [fillNonesTR]
state_before: α : Type u_1
as : List (Option α)
as' : List α
acc : Array α
x✝ : List α
⊢ fillNonesTR.go [] x✝ acc = acc.data ++ [].fillNones x✝
state_after: no goals
tactic: simp [fillNonesTR.go]
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
a : α
as : List (Option α)
as' : List α
⊢ fillNonesTR.go (some a :: as) as' acc = acc.data ++ (some a :: as).fillNones as'
state_after: no goals
tactic: simp [fillNonesTR.go, go _ as as']
state_before: α : Type u_1
as✝ : List (Option α)
as' : List α
acc : Array α
as : List (Option α)
⊢ fillNonesTR.go (none :: as) [] acc = acc.data ++ (none :: as).fillNones []
state_after: no goals
tactic: simp [fillNonesTR.go, reduceOption, filterMap_eq_filterMapTR.go]
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
as : List (Option α)
a : α
as' : List α
⊢ fillNonesTR.go (none :: as) (a :: as') acc = acc.data ++ (none :: as).fillNones (a :: as')
state_after: no goals
tactic: simp [fillNonesTR.go, go _ as as']
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ as.fillNones as' = fillNonesTR.go as as' #[]
state_after: no goals
tactic: simp [fillNonesTR, go]
Theorem: Matrix.blockTriangular_blockDiagonal
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
⊢ (blockDiagonal d).BlockTriangular Prod.snd
state_after: case mk.mk
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ blockDiagonal d (i, i') (j, j') = 0
tactic: rintro ⟨i, i'⟩ ⟨j, j'⟩ h
state_before: case mk.mk
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ blockDiagonal d (i, i') (j, j') = 0
state_after: case mk.mk.a
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ ⟨j', j⟩.fst < ⟨i', i⟩.fst
tactic: rw [blockDiagonal'_eq_blockDiagonal, blockTriangular_blockDiagonal']
state_before: case mk.mk.a
α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝² : CommRing R
M N : Matrix m m R
b : m → α
inst✝¹ : Preorder α
inst✝ : DecidableEq α
d : α → Matrix m m R
i : m
i' : α
j : m
j' : α
h : (j, j').2 < (i, i').2
⊢ ⟨j', j⟩.fst < ⟨i', i⟩.fst
state_after: no goals
tactic: exact h
Theorem: AddMonoid.fg_of_surjective
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_3
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ⇑f
⊢ FG M'
state_after: no goals
tactic: classical
    obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
    use s.image f
    rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
      MonoidHom.mrange_top_iff_surjective]
Theorem: abs_sub_map_le_sub
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommGroup β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ |f x - f y| ≤ f (x / y)
state_after: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommGroup β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f x ≤ f y + f (x / y) ∧ f y ≤ f x + f (x / y)
tactic: rw [abs_sub_le_iff, sub_le_iff_le_add', sub_le_iff_le_add']
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : LinearOrderedAddCommGroup β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f x ≤ f y + f (x / y) ∧ f y ≤ f x + f (x / y)
state_after: no goals
tactic: exact ⟨le_map_add_map_div _ _ _, le_map_add_map_div' _ _ _⟩
Theorem: HomologicalComplex.d_pOpcycles
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝¹ : K.HasHomology i
inst✝ : K.HasHomology j
⊢ K.d i j ≫ K.pOpcycles j = 0
state_after: case pos
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝¹ : K.HasHomology i
inst✝ : K.HasHomology j
hij : c.Rel i j
⊢ K.d i j ≫ K.pOpcycles j = 0

case neg
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝¹ : K.HasHomology i
inst✝ : K.HasHomology j
hij : ¬c.Rel i j
⊢ K.d i j ≫ K.pOpcycles j = 0
tactic: by_cases hij : c.Rel i j
Theorem: Finset.mul_prod_Iio_eq_prod_Iic
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : PartialOrder α
inst✝¹ : CommMonoid M
f : α → M
a✝ b : α
inst✝ : LocallyFiniteOrderBot α
a : α
⊢ f a * ∏ x ∈ Iio a, f x = ∏ x ∈ Iic a, f x
state_after: no goals
tactic: rw [Iic_eq_cons_Iio, prod_cons]
Theorem: Codisjoint.himp_inf_cancel_left
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a ⊓ b = a
state_after: no goals
tactic: rw [himp_inf_distrib, himp_self, inf_top_eq, h.himp_eq_right]
Theorem: GaussianFourier.integrable_cexp_neg_mul_sq_add_real_mul_I
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

Proof steps:
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Integrable (fun x => cexp (-b * (↑x + ↑c * I) ^ 2)) volume
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun x => cexp (-b * (↑x + ↑c * I) ^ 2)) volume
tactic: refine
    ⟨(Complex.continuous_exp.comp
          (continuous_const.mul
            ((continuous_ofReal.add continuous_const).pow 2))).aestronglyMeasurable,
      ?_⟩
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun x => cexp (-b * (↑x + ↑c * I) ^ 2)) volume
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun a => ‖cexp (-b * (↑a + ↑c * I) ^ 2)‖) volume
tactic: rw [← hasFiniteIntegral_norm_iff]
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun a => ‖cexp (-b * (↑a + ↑c * I) ^ 2)‖) volume
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun a => rexp (c ^ 2 * (b.im ^ 2 / b.re + b.re)) * rexp (-(b.re * (a - b.im * c / b.re) ^ 2)))
    volume
tactic: simp_rw [norm_cexp_neg_mul_sq_add_mul_I' hb.ne', neg_sub _ (c ^ 2 * _),
    sub_eq_add_neg _ (b.re * _), Real.exp_add]
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ HasFiniteIntegral (fun a => rexp (c ^ 2 * (b.im ^ 2 / b.re + b.re)) * rexp (-(b.re * (a - b.im * c / b.re) ^ 2)))
    volume
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Integrable (fun x => rexp (-(b.re * x ^ 2))) volume
tactic: suffices Integrable fun x : ℝ => exp (-(b.re * x ^ 2)) by
    exact (Integrable.comp_sub_right this (b.im * c / b.re)).hasFiniteIntegral.const_mul _
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Integrable (fun x => rexp (-(b.re * x ^ 2))) volume
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Integrable (fun x => rexp (-b.re * x ^ 2)) volume
tactic: simp_rw [← neg_mul]
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Integrable (fun x => rexp (-b.re * x ^ 2)) volume
state_after: no goals
tactic: apply integrable_exp_neg_mul_sq hb
Theorem: nonempty_frontier_iff
File: Mathlib/Topology/Connected/Clopen.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : Set α
⊢ (frontier s).Nonempty ↔ s.Nonempty ∧ s ≠ univ
state_after: no goals
tactic: simp only [nonempty_iff_ne_empty, Ne, frontier_eq_empty_iff, not_or]
Theorem: CategoryTheory.Center.rightUnitor_inv_f
File: Mathlib/CategoryTheory/Monoidal/Center.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (ρ_ X).inv.f = (ρ_ X.fst).inv
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (ρ_ X.fst).hom ≫ (ρ_ X).inv.f = 𝟙 (X ⊗ 𝟙_ (Center C)).fst
tactic: apply Iso.inv_ext'
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (ρ_ X.fst).hom ≫ (ρ_ X).inv.f = 𝟙 (X ⊗ 𝟙_ (Center C)).fst
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (𝟙 (X ⊗ 𝟙_ (Center C))).f = 𝟙 (X ⊗ 𝟙_ (Center C)).fst
tactic: rw [← rightUnitor_hom_f, ← comp_f, Iso.hom_inv_id]
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X : Center C
⊢ (𝟙 (X ⊗ 𝟙_ (Center C))).f = 𝟙 (X ⊗ 𝟙_ (Center C)).fst
state_after: no goals
tactic: rfl
Theorem: IsRightRegular.of_mul
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
⊢ IsRightRegular b
state_after: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * (b * a) = y * (b * a)
tactic: refine fun x y xy => ab (?_ : x * (b * a) = y * (b * a))
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * (b * a) = y * (b * a)
state_after: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * b * a = y * b * a
tactic: rw [← mul_assoc, ← mul_assoc]