ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.withDensityᵥ_smul_eq_withDensityᵥ_withDensity
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ : α → E
f : α → ℝ≥0
g : α → E
hf : AEMeasurable f μ
hfg : Integrable (f • g) μ
⊢ μ.withDensityᵥ (f • g) = (μ.withDensity fun x => ↑(f x)).withDensityᵥ g
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ : α → E
f : α → ℝ≥0
g : α → E
hf : AEMeasurable f μ
hfg : Integrable (f • g) μ
s : Set α
hs : MeasurableSet s
⊢ ↑(μ.withDensityᵥ (f • g)) s = ↑((μ.withDensity fun x => ↑(f x)).withDensityᵥ g) s
tactic: ext s hs
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ : α → E
f : α → ℝ≥0
g : α → E
hf : AEMeasurable f μ
hfg : Integrable (f • g) μ
s : Set α
hs : MeasurableSet s
⊢ ↑(μ.withDensityᵥ (f • g)) s = ↑((μ.withDensity fun x => ↑(f x)).withDensityᵥ g) s
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ : α → E
f : α → ℝ≥0
g : α → E
hf : AEMeasurable f μ
hfg : Integrable (f • g) μ
s : Set α
hs : MeasurableSet s
⊢ ∫ (x : α) in s, (f • g) x ∂μ = ∫ (x : α) in s, f x • g x ∂μ
tactic: rw [withDensityᵥ_apply hfg hs,
    withDensityᵥ_apply ((integrable_withDensity_iff_integrable_smul₀ hf).mpr hfg) hs,
    setIntegral_withDensity_eq_setIntegral_smul₀ hf.restrict _ hs]
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ : α → E
f : α → ℝ≥0
g : α → E
hf : AEMeasurable f μ
hfg : Integrable (f • g) μ
s : Set α
hs : MeasurableSet s
⊢ ∫ (x : α) in s, (f • g) x ∂μ = ∫ (x : α) in s, f x • g x ∂μ
state_after: no goals
tactic: rfl
Theorem: Metric.hausdorffDist_le_diam
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : s.Nonempty
bs : Bornology.IsBounded s
ht : t.Nonempty
bt : Bornology.IsBounded t
⊢ hausdorffDist s t ≤ diam (s ∪ t)
state_after: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y : α
Φ : α → β
bs : Bornology.IsBounded s
ht : t.Nonempty
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
⊢ hausdorffDist s t ≤ diam (s ∪ t)
tactic: rcases hs with ⟨x, xs⟩
state_before: case intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y : α
Φ : α → β
bs : Bornology.IsBounded s
ht : t.Nonempty
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
⊢ hausdorffDist s t ≤ diam (s ∪ t)
state_after: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ hausdorffDist s t ≤ diam (s ∪ t)
tactic: rcases ht with ⟨y, yt⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ hausdorffDist s t ≤ diam (s ∪ t)
state_after: case intro.intro.refine_1
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ ∀ x ∈ s, ∃ y ∈ t, dist x y ≤ diam (s ∪ t)

case intro.intro.refine_2
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
bs : Bornology.IsBounded s
bt : Bornology.IsBounded t
x : α
xs : x ∈ s
y : α
yt : y ∈ t
⊢ ∀ x ∈ t, ∃ y ∈ s, dist x y ≤ diam (s ∪ t)
tactic: refine hausdorffDist_le_of_mem_dist diam_nonneg ?_ ?_
Theorem: Matrix.isSkewAdjoint_bracket
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

Proof steps:
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : A ∈ skewAdjointMatricesSubmodule J
hB : B ∈ skewAdjointMatricesSubmodule J
⊢ ⁅A, B⁆ ∈ skewAdjointMatricesSubmodule J
state_after: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : J.IsSkewAdjoint A
hB : J.IsSkewAdjoint B
⊢ J.IsSkewAdjoint ⁅A, B⁆
tactic: simp only [mem_skewAdjointMatricesSubmodule] at *
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : J.IsSkewAdjoint A
hB : J.IsSkewAdjoint B
⊢ J.IsSkewAdjoint ⁅A, B⁆
state_after: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : J.IsSkewAdjoint A
hB : J.IsSkewAdjoint B
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
tactic: change ⁅A, B⁆ᵀ * J = J * (-⁅A, B⁆)
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : J.IsSkewAdjoint A
hB : J.IsSkewAdjoint B
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
state_after: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hB : J.IsSkewAdjoint B
hA : Aᵀ * J = J * -A
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
tactic: change Aᵀ * J = J * (-A) at hA
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hB : J.IsSkewAdjoint B
hA : Aᵀ * J = J * -A
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
state_after: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : Aᵀ * J = J * -A
hB : Bᵀ * J = J * -B
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
tactic: change Bᵀ * J = J * (-B) at hB
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : Aᵀ * J = J * -A
hB : Bᵀ * J = J * -B
⊢ ⁅A, B⁆ᵀ * J = J * -⁅A, B⁆
state_after: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : Aᵀ * J = J * -A
hB : Bᵀ * J = J * -B
⊢ J * -B * -A - J * -A * -B = J * -(A * B - B * A)
tactic: rw [Matrix.lie_transpose, LieRing.of_associative_ring_bracket,
    LieRing.of_associative_ring_bracket, sub_mul, mul_assoc, mul_assoc, hA, hB, ← mul_assoc,
    ← mul_assoc, hA, hB]
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
hA : Aᵀ * J = J * -A
hB : Bᵀ * J = J * -B
⊢ J * -B * -A - J * -A * -B = J * -(A * B - B * A)
state_after: no goals
tactic: noncomm_ring
Theorem: Cycle.toFinset_eq_nil
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
⊢ ∀ (a : List α), toFinset (Quotient.mk'' a) = ∅ ↔ Quotient.mk'' a = nil
state_after: no goals
tactic: simp
Theorem: UniqueFactorizationMonoid.mem_normalizedFactors_iff
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : NormalizationMonoid α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Unique αˣ
p x : α
hx : x ≠ 0
⊢ p ∈ normalizedFactors x ↔ Prime p ∧ p ∣ x
state_after: case mp
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : NormalizationMonoid α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Unique αˣ
p x : α
hx : x ≠ 0
⊢ p ∈ normalizedFactors x → Prime p ∧ p ∣ x

case mpr
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : NormalizationMonoid α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Unique αˣ
p x : α
hx : x ≠ 0
⊢ Prime p ∧ p ∣ x → p ∈ normalizedFactors x
tactic: constructor
Theorem: Int.lt_asymm
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → ¬b < a
state_after: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → a ≤ b
tactic: rw [Int.not_lt]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a < b → a ≤ b
state_after: no goals
tactic: exact Int.le_of_lt
Theorem: Orientation.right_ne_zero_of_oangle_ne_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y ≠ 0
⊢ y ≠ 0
state_after: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
h : o.oangle x 0 ≠ 0
⊢ False
tactic: rintro rfl
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
h : o.oangle x 0 ≠ 0
⊢ False
state_after: no goals
tactic: simp at h
Theorem: Real.cos_nat_mul_two_pi_sub_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ cos (↑n * (2 * π) - π) = -1
state_after: no goals
tactic: simpa only [cos_zero] using (cos_periodic.nat_mul n).sub_antiperiod_eq cos_antiperiodic
Theorem: Hyperreal.isSt_iff_tendsto
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
r : ℝ
⊢ x.IsSt r ↔ Germ.Tendsto x (𝓝 r)
state_after: case intro
r : ℝ
f : ℕ → ℝ
⊢ (ofSeq f).IsSt r ↔ Germ.Tendsto (ofSeq f) (𝓝 r)
tactic: rcases ofSeq_surjective x with ⟨f, rfl⟩
state_before: case intro
r : ℝ
f : ℕ → ℝ
⊢ (ofSeq f).IsSt r ↔ Germ.Tendsto (ofSeq f) (𝓝 r)
state_after: no goals
tactic: exact isSt_ofSeq_iff_tendsto
Theorem: Subgroup.closure_induction_right
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
p : (x : G) → x ∈ closure s → Prop
one : p 1 ⋯
mul_right : ∀ (x : G) (hx : x ∈ closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y) ⋯
mul_right_inv : ∀ (x : G) (hx : x ∈ closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y⁻¹) ⋯
x : G
h : x ∈ closure s
m : Gᵐᵒᵖ
hm : m ∈ closure (MulOpposite.unop ⁻¹' s)
⊢ MulOpposite.unop m ∈ closure s
state_after: no goals
tactic: rwa [← op_closure] at hm
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
p : (x : G) → x ∈ closure s → Prop
one : p 1 ⋯
mul_right : ∀ (x : G) (hx : x ∈ closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y) ⋯
mul_right_inv : ∀ (x : G) (hx : x ∈ closure s) (y : G) (hy : y ∈ s), p x hx → p (x * y⁻¹) ⋯
x : G
h : x ∈ closure s
⊢ { unop' := x } ∈ closure (MulOpposite.unop ⁻¹' s)
state_after: no goals
tactic: rwa [← op_closure]
Theorem: CategoryTheory.Biprod.isIso_inl_iff_isZero
File: Mathlib/CategoryTheory/Simple.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ IsIso biprod.inl ↔ IsZero Y
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ biprod.snd ≫ biprod.inr = 0 ↔ IsZero Y
tactic: rw [biprod.isIso_inl_iff_id_eq_fst_comp_inl, ← biprod.total, add_right_eq_self]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ biprod.snd ≫ biprod.inr = 0 ↔ IsZero Y
state_after: case mp
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ biprod.snd ≫ biprod.inr = 0 → IsZero Y

case mpr
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ IsZero Y → biprod.snd ≫ biprod.inr = 0
tactic: constructor
Theorem: HasStrictFDerivAt.implicitFunctionOfComplemented_apply_image
File: Mathlib/Analysis/Calculus/Implicit.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : (LinearMap.ker f').ClosedComplemented
⊢ implicitFunctionOfComplemented f f' hf hf' hker (f a) 0 = a
state_after: no goals
tactic: simpa only [implicitToPartialHomeomorphOfComplemented_self] using
      (hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker).left_inv
      (hf.mem_implicitToPartialHomeomorphOfComplemented_source hf' hker)
Theorem: MeasureTheory.JordanDecomposition.toSignedMeasure_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
⊢ toSignedMeasure 0 = 0
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
tactic: ext1 i hi
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
state_after: no goals
tactic: rw [toSignedMeasure, toSignedMeasure_sub_apply hi, zero_posPart, zero_negPart, sub_self,
    VectorMeasure.coe_zero, Pi.zero_apply]
Theorem: Representation.asGroupHom_apply
File: Mathlib/RepresentationTheory/Basic.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Group G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
⊢ ↑(ρ.asGroupHom g) = ρ g
state_after: no goals
tactic: simp only [asGroupHom, MonoidHom.coe_toHomUnits]
Theorem: LinearMap.BilinForm.isAdjointPair_zero
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : CommSemiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹¹ : CommRing R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁵ : AddCommMonoid M'✝
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M'✝
inst✝² : Module R M''
B : BilinForm R M
B₁ : BilinForm R₁ M₁
F : BilinForm R M
M' : Type u_9
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B' : BilinForm R M'
f f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
x : M
y : M'
⊢ (B' (0 x)) y = (B x) (0 y)
state_after: no goals
tactic: simp only [BilinForm.zero_left, BilinForm.zero_right, LinearMap.zero_apply]
Theorem: List.Nat.antidiagonal_succ'
File: Mathlib/Data/List/NatAntidiagonal.lean

Proof steps:
state_before: n : ℕ
⊢ antidiagonal (n + 1) = map (Prod.map id succ) (antidiagonal n) ++ [(n + 1, 0)]
state_after: n : ℕ
⊢ map (fun i => (i, n + 1 - i)) (range n) ++ [(n, 1), (n + 1, 0)] =
    map (Prod.map id succ ∘ fun i => (i, n - i)) (range n) ++ [Prod.map id succ (n, 0), (n + 1, 0)]
tactic: simp only [antidiagonal, range_succ, Nat.add_sub_cancel_left, map_append, append_assoc,
    Nat.sub_self, singleton_append, map_map, map]
state_before: n : ℕ
⊢ map (fun i => (i, n + 1 - i)) (range n) ++ [(n, 1), (n + 1, 0)] =
    map (Prod.map id succ ∘ fun i => (i, n - i)) (range n) ++ [Prod.map id succ (n, 0), (n + 1, 0)]
state_after: case e_a
n : ℕ
⊢ map (fun i => (i, n + 1 - i)) (range n) = map (Prod.map id succ ∘ fun i => (i, n - i)) (range n)
tactic: congr 1
state_before: case e_a
n : ℕ
⊢ map (fun i => (i, n + 1 - i)) (range n) = map (Prod.map id succ ∘ fun i => (i, n - i)) (range n)
state_after: case e_a.h
n : ℕ
⊢ ∀ a ∈ range n, (a, n + 1 - a) = (Prod.map id succ ∘ fun i => (i, n - i)) a
tactic: apply map_congr_left
state_before: case e_a.h
n : ℕ
⊢ ∀ a ∈ range n, (a, n + 1 - a) = (Prod.map id succ ∘ fun i => (i, n - i)) a
state_after: no goals
tactic: simp (config := { contextual := true }) [le_of_lt, Nat.sub_add_comm]
Theorem: ArithmeticFunction.prod_eq_iff_prod_pow_moebius_eq_on_of_nonzero
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommGroupWithZero R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
f g : ℕ → R
hf : ∀ n > 0, f n ≠ 0
hg : ∀ n > 0, g n ≠ 0
⊢ (∀ n > 0, n ∈ s → ∏ i ∈ n.divisors, f i = g n) ↔ ∀ n > 0, n ∈ s → ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ μ x.1 = f n
state_after: case refine_1
R : Type u_1
inst✝ : CommGroupWithZero R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
f g : ℕ → R
hf : ∀ n > 0, f n ≠ 0
hg : ∀ n > 0, g n ≠ 0
n : ℕ
hn : n > 0
⊢ n ∈ s → ∏ i ∈ n.divisors, f i = g n ↔
    n ∈ s →
      ∏ i ∈ n.divisors, (fun n => if h : 0 < n then Units.mk0 (f n) ⋯ else 1) i =
        (fun n => if h : 0 < n then Units.mk0 (g n) ⋯ else 1) n

case refine_2
R : Type u_1
inst✝ : CommGroupWithZero R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
f g : ℕ → R
hf : ∀ n > 0, f n ≠ 0
hg : ∀ n > 0, g n ≠ 0
n : ℕ
hn : n > 0
⊢ n ∈ s →
      ∏ x ∈ n.divisorsAntidiagonal, (fun n => if h : 0 < n then Units.mk0 (g n) ⋯ else 1) x.2 ^ μ x.1 =
        (fun n => if h : 0 < n then Units.mk0 (f n) ⋯ else 1) n ↔
    n ∈ s → ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ μ x.1 = f n
tactic: refine
      Iff.trans
        (Iff.trans (forall_congr' fun n => ?_)
          (@prod_eq_iff_prod_pow_moebius_eq_on Rˣ _
            (fun n => if h : 0 < n then Units.mk0 (f n) (hf n h) else 1)
            (fun n => if h : 0 < n then Units.mk0 (g n) (hg n h) else 1)
            s hs) )
        (forall_congr' fun n => ?_) <;>
    refine imp_congr_right fun hn => ?_
Theorem: Set.univ_div_univ
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ univ / univ = univ
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: DihedralGroup.reciprocalFactors_zero
File: Mathlib/GroupTheory/CommutingProbability.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ reciprocalFactors 0 = [0]
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ (if h0 : 0 = 0 then [0]
    else
      if h1 : 0 = 1 then []
      else if Even 0 then 3 :: reciprocalFactors (0 / 2) else 0 % 4 * 0 :: reciprocalFactors (0 / 4 + 1)) =
    [0]
tactic: unfold reciprocalFactors
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
⊢ (if h0 : 0 = 0 then [0]
    else
      if h1 : 0 = 1 then []
      else if Even 0 then 3 :: reciprocalFactors (0 / 2) else 0 % 4 * 0 :: reciprocalFactors (0 / 4 + 1)) =
    [0]
state_after: no goals
tactic: rfl
Theorem: Set.sigma_diff_sigma
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
x : (i : ι) × α i
⊢ x ∈ s₁.sigma t₁ \ s₂.sigma t₂ ↔ x ∈ s₁.sigma (t₁ \ t₂) ∪ (s₁ \ s₂).sigma t₁
state_after: no goals
tactic: by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ x.1 <;> simp [*, ← imp_iff_or_not]
Theorem: CategoryTheory.Over.eqToHom_left
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U V : Over X
e : U = V
⊢ (eqToHom e).left = eqToHom ⋯
state_after: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U : Over X
⊢ (eqToHom ⋯).left = eqToHom ⋯
tactic: subst e
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X : T
U : Over X
⊢ (eqToHom ⋯).left = eqToHom ⋯
state_after: no goals
tactic: rfl
Theorem: Composition.sum_blocksFun
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
⊢ ∑ i : Fin c.length, c.blocksFun i = n
state_after: no goals
tactic: conv_rhs => rw [← c.blocks_sum, ← ofFn_blocksFun, sum_ofFn]
Theorem: Submodule.le_traceDual_comm
File: Mathlib/RingTheory/DedekindDomain/Different.lean

Proof steps:
state_before: A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁷ : CommRing A
inst✝¹⁶ : Field K
inst✝¹⁵ : CommRing B
inst✝¹⁴ : Field L
inst✝¹³ : Algebra A K
inst✝¹² : Algebra B L
inst✝¹¹ : Algebra A B
inst✝¹⁰ : Algebra K L
inst✝⁹ : Algebra A L
inst✝⁸ : IsScalarTower A K L
inst✝⁷ : IsScalarTower A B L
inst✝⁶ : IsDomain A
inst✝⁵ : IsFractionRing A K
inst✝⁴ : IsIntegralClosure B A L
inst✝³ : IsFractionRing B L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra.IsSeparable K L
inst✝ : IsDomain B
I J : Submodule B L
⊢ I ≤ Jᵛ ↔ J ≤ Iᵛ
state_after: no goals
tactic: rw [le_traceDual, mul_comm, ← le_traceDual]
Theorem: Real.range_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x y : ℝ
⊢ range arcsin = Icc (-(π / 2)) (π / 2)
state_after: x y : ℝ
⊢ Subtype.val '' range (IccExtend arcsin.proof_2 ⇑sinOrderIso.symm) = Icc (-(π / 2)) (π / 2)
tactic: rw [arcsin, range_comp Subtype.val]
state_before: x y : ℝ
⊢ Subtype.val '' range (IccExtend arcsin.proof_2 ⇑sinOrderIso.symm) = Icc (-(π / 2)) (π / 2)
state_after: no goals
tactic: simp [Icc]
Theorem: Real.two_mul_arctan_inv_3_add_arctan_inv_7
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: ⊢ 2 * arctan 3⁻¹ + arctan 7⁻¹ = π / 4
state_after: no goals
tactic: rw [two_mul_arctan, arctan_add] <;> norm_num