ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.mex_le_of_ne
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_4
f : ι → Ordinal.{max u_5 u_4}
a : Ordinal.{max u_5 u_4}
ha : ∀ (i : ι), f i ≠ a
⊢ a ∈ (range f)ᶜ
state_after: no goals
tactic: simp [ha]
Theorem: Mathlib.Tactic.Ring.one_pow
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R
b : ℕ
⊢ Nat.rawCast 1 ^ b = Nat.rawCast 1
state_after: no goals
tactic: simp
Theorem: Associates.finprod_ne_zero
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
⊢ Associates.mk (∏ᶠ (v : HeightOneSpectrum R), v.maxPowDividing I) ≠ 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
⊢ (if h : (mulSupport fun v => v.maxPowDividing I).Finite then ∏ i ∈ h.toFinset, i.maxPowDividing I else 1) ≠ 0
tactic: rw [Associates.mk_ne_zero, finprod_def]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
⊢ (if h : (mulSupport fun v => v.maxPowDividing I).Finite then ∏ i ∈ h.toFinset, i.maxPowDividing I else 1) ≠ 0
state_after: case pos
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
h✝ : (mulSupport fun v => v.maxPowDividing I).Finite
⊢ ∏ v ∈ h✝.toFinset, v.maxPowDividing I ≠ 0

case neg
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : Ideal R
h✝ : ¬(mulSupport fun v => v.maxPowDividing I).Finite
⊢ 1 ≠ 0
tactic: split_ifs
Theorem: MeasurableSpace.CountablyGenerated.comap
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace β
h : CountablyGenerated β
f : α → β
⊢ CountablyGenerated α
state_after: case mk.intro.intro
α : Type u_1
β : Type u_2
f : α → β
b : Set (Set β)
hbc : b.Countable
⊢ CountablyGenerated α
tactic: rcases h with ⟨⟨b, hbc, rfl⟩⟩
state_before: case mk.intro.intro
α : Type u_1
β : Type u_2
f : α → β
b : Set (Set β)
hbc : b.Countable
⊢ CountablyGenerated α
state_after: case mk.intro.intro
α : Type u_1
β : Type u_2
f : α → β
b : Set (Set β)
hbc : b.Countable
this : MeasurableSpace α := generateFrom (preimage f '' b)
⊢ CountablyGenerated α
tactic: letI := generateFrom (preimage f '' b)
state_before: case mk.intro.intro
α : Type u_1
β : Type u_2
f : α → β
b : Set (Set β)
hbc : b.Countable
this : MeasurableSpace α := generateFrom (preimage f '' b)
⊢ CountablyGenerated α
state_after: no goals
tactic: exact ⟨_, hbc.image _, rfl⟩
Theorem: Nat.eq_one_iff_not_exists_prime_dvd
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ n = 1 ↔ ∀ (p : ℕ), Prime p → ¬p ∣ n
state_after: no goals
tactic: simpa using not_iff_not.mpr ne_one_iff_exists_prime_dvd
Theorem: uniformContinuous_monoidHom_of_continuous
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_3
inst✝⁴ : UniformSpace β
inst✝³ : Group β
inst✝² : UniformGroup β
inst✝¹ : FunLike hom α β
inst✝ : MonoidHomClass hom α β
f : hom
h : Continuous ⇑f
this : Tendsto (⇑f) (𝓝 1) (𝓝 (f 1))
⊢ Tendsto (⇑f) (𝓝 1) (𝓝 1)
state_after: no goals
tactic: rwa [map_one] at this
Theorem: CategoryTheory.shiftFunctorAdd'_assoc_hom_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
X : C
⊢ a₁₂ + a₃ = a₁₂₃
state_after: no goals
tactic: rw [← h₁₂, h₁₂₃]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
X : C
⊢ a₁ + a₂₃ = a₁₂₃
state_after: no goals
tactic: rw [← h₂₃, ← add_assoc, h₁₂₃]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
X : C
⊢ (shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯).hom.app X ≫
      (shiftFunctor C a₃).map ((shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).hom.app X) =
    (shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯).hom.app X ≫
      (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).hom.app ((shiftFunctor C a₁).obj X)
state_after: no goals
tactic: simpa using NatTrans.congr_app (congr_arg Iso.hom
    (shiftFunctorAdd'_assoc C _ _ _ _ _ _ h₁₂ h₂₃ h₁₂₃)) X
Theorem: Irrational.rat_add
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
h : Irrational x
⊢ Irrational (↑(-q) + (↑q + x))
state_after: no goals
tactic: rwa [cast_neg, neg_add_cancel_left]
Theorem: Polynomial.bernoulli_def
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

Proof steps:
state_before: n : ℕ
⊢ bernoulli n = ∑ i ∈ range (n + 1), (monomial i) (_root_.bernoulli (n - i) * ↑(n.choose i))
state_after: n : ℕ
⊢ ∑ i ∈ range (n + 1), (monomial (n - i)) (_root_.bernoulli i * ↑(n.choose i)) =
    ∑ j ∈ range (n + 1), (monomial (n - j)) (_root_.bernoulli (n - (n - j)) * ↑(n.choose (n - j)))
tactic: rw [← sum_range_reflect, add_succ_sub_one, add_zero, bernoulli]
state_before: n : ℕ
⊢ ∑ i ∈ range (n + 1), (monomial (n - i)) (_root_.bernoulli i * ↑(n.choose i)) =
    ∑ j ∈ range (n + 1), (monomial (n - j)) (_root_.bernoulli (n - (n - j)) * ↑(n.choose (n - j)))
state_after: n : ℕ
⊢ ∀ x ∈ range (n + 1),
    (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
      (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
tactic: apply sum_congr rfl
state_before: n : ℕ
⊢ ∀ x ∈ range (n + 1),
    (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
      (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: n x : ℕ
hx : x ∈ range (n + 1)
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
tactic: rintro x hx
state_before: n x : ℕ
hx : x ∈ range (n + 1)
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: n x : ℕ
hx : x ≤ n
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
tactic: rw [mem_range_succ_iff] at hx
state_before: n x : ℕ
hx : x ≤ n
⊢ (monomial (n - x)) (_root_.bernoulli x * ↑(n.choose x)) =
    (monomial (n - x)) (_root_.bernoulli (n - (n - x)) * ↑(n.choose (n - x)))
state_after: no goals
tactic: rw [choose_symm hx, tsub_tsub_cancel_of_le hx]
Theorem: AddHom.inverse_apply
File: Mathlib/Algebra/Group/Equiv/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
f : M →ₙ* N
g : N → M
h₁ : LeftInverse g ⇑f
h₂ : Function.RightInverse g ⇑f
x y : N
⊢ g (x * y) = g (f (g x) * f (g y))
state_after: no goals
tactic: rw [h₂ x, h₂ y]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
f : M →ₙ* N
g : N → M
h₁ : LeftInverse g ⇑f
h₂ : Function.RightInverse g ⇑f
x y : N
⊢ g (f (g x) * f (g y)) = g (f (g x * g y))
state_after: no goals
tactic: rw [f.map_mul]
Theorem: Monoid.Coprod.con_mul_left_inv
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
x : FreeMonoid (G ⊕ H)
⊢ (coprodCon G H) (ofList (List.map (Sum.map Inv.inv Inv.inv) (toList x)).reverse * x) 1
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
x : FreeMonoid (G ⊕ H)
⊢ mk (ofList (List.map (Sum.map Inv.inv Inv.inv) (toList x)).reverse) * mk x = 1
tactic: rw [← mk_eq_mk, map_mul, map_one]
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
x : FreeMonoid (G ⊕ H)
⊢ mk (ofList (List.map (Sum.map Inv.inv Inv.inv) (toList x)).reverse) * mk x = 1
state_after: no goals
tactic: induction x with
  | h0 => simp [map_one mk] -- TODO: fails without `[map_one mk]`
  | ih x xs ihx =>
    simp only [toList_of_mul, map_cons, reverse_cons, ofList_append, map_mul, ihx, ofList_singleton]
    rwa [mul_assoc, ← mul_assoc (mk (of _)), mk_of_inv_mul, one_mul]
Theorem: LinearOrderedField.coe_lt_inducedMap_iff
File: Mathlib/Algebra/Order/CompleteField.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
⊢ ↑q < inducedMap α β a ↔ ↑q < a
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
h : ↑q < inducedMap α β a
⊢ ↑q < a

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
hq : ↑q < a
⊢ ↑q < inducedMap α β a
tactic: refine ⟨fun h => ?_, fun hq => ?_⟩
Theorem: JoinedIn.symm
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
⊢ JoinedIn F y x
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
hx : x ∈ F
hy : y ∈ F
⊢ JoinedIn F y x
tactic: cases' h.mem with hx hy
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
h : JoinedIn F x y
hx : x ∈ F
hy : y ∈ F
⊢ JoinedIn F y x
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hx✝ : x ∈ F
hy✝ : y ∈ F
h : Joined ⟨x, ⋯⟩ ⟨y, ⋯⟩
hx : x ∈ F
hy : y ∈ F
⊢ Joined ⟨y, ⋯⟩ ⟨x, ⋯⟩
tactic: simp_all [joinedIn_iff_joined]
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
hx✝ : x ∈ F
hy✝ : y ∈ F
h : Joined ⟨x, ⋯⟩ ⟨y, ⋯⟩
hx : x ∈ F
hy : y ∈ F
⊢ Joined ⟨y, ⋯⟩ ⟨x, ⋯⟩
state_after: no goals
tactic: exact h.symm
Theorem: ContinuousMap.toNNReal_mul_add_neg_mul_add_mul_neg_eq
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
⊢ (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
    (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) x) =
    ↑(((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal) x)
tactic: ext x
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) x) =
    ↑(((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal) x)
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x * g x) 0 + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0) +
      (-(max (f x) 0 * g x) + max (f x) 0 * max (g x) 0) =
    -(f x * g x) + max (f x * g x) 0 + max (f x) 0 * max (g x) 0 +
      (-(max (f x) 0 * g x) + f x * g x + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0))
tactic: simp [max_neg_zero, add_mul, mul_add]
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x * g x) 0 + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0) +
      (-(max (f x) 0 * g x) + max (f x) 0 * max (g x) 0) =
    -(f x * g x) + max (f x * g x) 0 + max (f x) 0 * max (g x) 0 +
      (-(max (f x) 0 * g x) + f x * g x + (-(f x * max (g x) 0) + max (f x) 0 * max (g x) 0))
state_after: no goals
tactic: abel
Theorem: Derivation.comp_aeval_eq
File: Mathlib/Algebra/Polynomial/Derivation.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
M : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
d✝ : Derivation R A M
a : A
d : Derivation R A M
f : R[X]
⊢ (AEval.of R M a).symm ((d.compAEval a) f) = (aeval a) (derivative f) • d a
state_after: no goals
tactic: simp [-compAEval_apply, compAEval_eq]
Theorem: Bitraversable.tsnd_eq_snd_id'
File: Mathlib/Control/Bitraversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : LawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β β' : Type u
f : β → β'
x : t α β
⊢ tsnd (pure ∘ f) x = pure (snd f x)
state_after: no goals
tactic: apply bitraverse_eq_bimap_id
Theorem: LieModule.weightSpace_chainBotCoeff_sub_one_zsmul_sub
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ weightSpace M ((-↑(chainBotCoeff α β) - 1) • α + ⇑β) = ⊥
state_after: no goals
tactic: rw [sub_eq_add_neg, ← neg_add, neg_smul, ← smul_neg, chainBotCoeff,
    weightSpace_chainTopCoeff_add_one_zsmul_add _ _ (by simpa using hα)]
Theorem: Ordnode.Valid'.node4L_lemma₃
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
b c d : ℕ
mr₁ : 2 * d ≤ b + c + 1
mm₁ : b ≤ 3 * c
⊢ d ≤ 3 * c
state_after: no goals
tactic: omega
Theorem: MeasureTheory.Measure.map_linearMap_addHaar_pi_eq_smul_addHaar
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
tactic: cases nonempty_fintype ι
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
this : μ = μ ↑(piIcc01 ι) • addHaarMeasure (piIcc01 ι)
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
tactic: have := addHaarMeasure_unique μ (piIcc01 ι)
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
this : μ = μ ↑(piIcc01 ι) • addHaarMeasure (piIcc01 ι)
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: no goals
tactic: rw [this, addHaarMeasure_eq_volume_pi, Measure.map_smul,
    Real.map_linearMap_volume_pi_eq_smul_volume_pi hf, smul_comm]
Theorem: SimpleGraph.Walk.edges_transfer
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u✝ v✝ u' v' : V
p✝ : G.Walk u✝ v✝
u v : V
p : G.Walk u v
H : SimpleGraph V
hp : ∀ e ∈ p.edges, e ∈ H.edgeSet
⊢ (p.transfer H hp).edges = p.edges
state_after: no goals
tactic: induction p <;> simp [*]
Theorem: MvPowerSeries.coeff_truncFun
File: Mathlib/RingTheory/MvPowerSeries/Trunc.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : σ →₀ ℕ
φ : MvPowerSeries σ R
⊢ MvPolynomial.coeff m (truncFun n φ) = if m < n then (coeff R m) φ else 0
state_after: no goals
tactic: classical
  simp [truncFun, MvPolynomial.coeff_sum]
Theorem: CategoryTheory.braiding_tensorUnit_left
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ (𝟙_ C) X).hom = (λ_ X).hom ≫ (ρ_ X).inv
state_after: no goals
tactic: simp [← braiding_rightUnitor]
Theorem: ENNReal.tsum_mul_left
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
⊢ ∑' (i : α), a * f i = a * ∑' (i : α), f i
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ∀ (i : α), f i = 0
⊢ ∑' (i : α), a * f i = a * ∑' (i : α), f i

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α → ℝ≥0∞
hf : ¬∀ (i : α), f i = 0
⊢ ∑' (i : α), a * f i = a * ∑' (i : α), f i
tactic: by_cases hf : ∀ i, f i = 0
Theorem: Set.Finite.cast_ncard_eq
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
hs : s.Finite
⊢ ↑s.ncard = s.encard
state_after: no goals
tactic: rwa [ncard, ENat.coe_toNat_eq_self, ne_eq, encard_eq_top_iff, Set.Infinite, not_not]
Theorem: SimpleGraph.isNClique_zero
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ G.IsNClique 0 s ↔ s = ∅
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ s = ∅ → G.IsClique ↑s
tactic: simp only [isNClique_iff, Finset.card_eq_zero, and_iff_right_iff_imp]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ s = ∅ → G.IsClique ↑s
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a b c : α
⊢ G.IsClique ↑∅
tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a b c : α
⊢ G.IsClique ↑∅
state_after: no goals
tactic: simp
Theorem: MvPolynomial.C_mul_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ C a * (monomial s) a' = (monomial s) (a * a')
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ AddMonoidAlgebra.single 0 a * AddMonoidAlgebra.single s a' = AddMonoidAlgebra.single s (a * a')
tactic: show AddMonoidAlgebra.single _ _ * AddMonoidAlgebra.single _ _ = AddMonoidAlgebra.single _ _
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ AddMonoidAlgebra.single 0 a * AddMonoidAlgebra.single s a' = AddMonoidAlgebra.single s (a * a')
state_after: no goals
tactic: simp [C_apply, single_mul_single]
Theorem: Polynomial.monic_X_sub_C
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p : R[X]
x : R
⊢ (X - C x).Monic
state_after: no goals
tactic: simpa only [sub_eq_add_neg, C_neg] using monic_X_add_C (-x)
Theorem: Functor.Comp.pure_seq_eq_map
File: Mathlib/Control/Applicative.lean

Proof steps:
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type v
f : α → β
x : Comp F G α
⊢ (Seq.seq (pure f) fun x_1 => x).run = (f <$> x).run
state_after: no goals
tactic: simp [Applicative.pure_seq_eq_map', functor_norm]
Theorem: MeasureTheory.SimpleFunc.restrict_preimage
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
K : Type u_5
inst✝ : Zero β
f : α →ₛ β
s : Set α
hs : MeasurableSet s
t : Set β
ht : 0 ∉ t
⊢ ↑(f.restrict s) ⁻¹' t = s ∩ ↑f ⁻¹' t
state_after: no goals
tactic: simp [hs, indicator_preimage_of_not_mem _ _ ht, inter_comm]
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.sieveOfSection_apply
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
V W : C
i : V ⟶ unop U
hi : (fun V f => F.map f.op s ∈ G.obj (op V)) V i
j : W ⟶ V
⊢ (fun V f => F.map f.op s ∈ G.obj (op V)) W (j ≫ i)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
V W : C
i : V ⟶ unop U
hi : (fun V f => F.map f.op s ∈ G.obj (op V)) V i
j : W ⟶ V
⊢ F.map j.op (F.map i.op s) ∈ G.obj (op W)
tactic: simp only [op_unop, op_comp, FunctorToTypes.map_comp_apply]
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
V W : C
i : V ⟶ unop U
hi : (fun V f => F.map f.op s ∈ G.obj (op V)) V i
j : W ⟶ V
⊢ F.map j.op (F.map i.op s) ∈ G.obj (op W)
state_after: no goals
tactic: exact G.map _ hi
Theorem: MeasureTheory.pdf.lintegral_pdf_mul
File: Mathlib/Probability/Density.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : E), pdf X ℙ μ x * f x ∂μ = ∫⁻ (x : Ω), f (X x) ∂ℙ
state_after: no goals
tactic: rw [pdf_def,
    ← lintegral_map' (hf.mono_ac HasPDF.absolutelyContinuous) (HasPDF.aemeasurable X ℙ μ),
    lintegral_rnDeriv_mul HasPDF.absolutelyContinuous hf]