ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integral_comp_abs
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

Proof steps:
state_before: f : ℝ → ℝ
⊢ ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Ioi 0, f x
state_after: f : ℝ → ℝ
eq : ∫ (x : ℝ) in Ioi 0, f |x| = ∫ (x : ℝ) in Ioi 0, f x
⊢ ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Ioi 0, f x
tactic: have eq : ∫ (x : ℝ) in Ioi 0, f |x| = ∫ (x : ℝ) in Ioi 0, f x := by
    refine setIntegral_congr measurableSet_Ioi (fun _ hx => ?_)
    rw [abs_eq_self.mpr (le_of_lt (by exact hx))]
state_before: f : ℝ → ℝ
eq : ∫ (x : ℝ) in Ioi 0, f |x| = ∫ (x : ℝ) in Ioi 0, f x
⊢ ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Ioi 0, f x
state_after: case pos
f : ℝ → ℝ
eq : ∫ (x : ℝ) in Ioi 0, f |x| = ∫ (x : ℝ) in Ioi 0, f x
hf : IntegrableOn (fun x => f |x|) (Ioi 0) volume
⊢ ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Ioi 0, f x

case neg
f : ℝ → ℝ
eq : ∫ (x : ℝ) in Ioi 0, f |x| = ∫ (x : ℝ) in Ioi 0, f x
hf : ¬IntegrableOn (fun x => f |x|) (Ioi 0) volume
⊢ ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Ioi 0, f x
tactic: by_cases hf : IntegrableOn (fun x => f |x|) (Ioi 0)
Theorem: OreLocalization.smul_oreDiv
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 : X
s : ↥S
⊢ r • (x /ₒ s) = oreNum (r • 1) s • x /ₒ oreDenom (r • 1) s
state_after: no goals
tactic: with_unfolding_all rfl
Theorem: IsPGroup.index
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
⊢ ∃ n, H.index = p ^ n
state_after: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
n : ℕ
hn : Nat.card (G ⧸ H.normalCore) = p ^ n
⊢ ∃ n, H.index = p ^ n
tactic: obtain ⟨n, hn⟩ := iff_card.mp (hG.to_quotient H.normalCore)
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
n : ℕ
hn : Nat.card (G ⧸ H.normalCore) = p ^ n
⊢ ∃ n, H.index = p ^ n
state_after: case intro.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
n : ℕ
hn : Nat.card (G ⧸ H.normalCore) = p ^ n
k : ℕ
left✝ : k ≤ n
hk2 : H.index = p ^ k
⊢ ∃ n, H.index = p ^ n
tactic: obtain ⟨k, _, hk2⟩ :=
    (Nat.dvd_prime_pow hp.out).mp
      ((congr_arg _ (H.normalCore.index_eq_card.trans hn)).mp
        (Subgroup.index_dvd_of_le H.normalCore_le))
state_before: case intro.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
n : ℕ
hn : Nat.card (G ⧸ H.normalCore) = p ^ n
k : ℕ
left✝ : k ≤ n
hk2 : H.index = p ^ k
⊢ ∃ n, H.index = p ^ n
state_after: no goals
tactic: exact ⟨k, hk2⟩
Theorem: CategoryTheory.ShortComplex.SnakeInput.snd_δ_inr
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ pullback.snd S.L₁.g S.v₀₁.τ₃ ≫ S.δ ≫ pushout.inr S.L₂.f S.v₂₃.τ₁ =
    pullback.fst S.L₁.g S.v₀₁.τ₃ ≫ S.v₁₂.τ₂ ≫ pushout.inl S.L₂.f S.v₂₃.τ₁
state_after: no goals
tactic: simp only [snd_δ_assoc, ← pushout.condition, φ₂, φ₁_L₂_f_assoc, assoc]
Theorem: Polynomial.natDegree_mul_X_pow
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
hp : p ≠ 0
⊢ (p * X ^ n).natDegree = p.natDegree + n
state_after: no goals
tactic: rw [natDegree_mul' (by simpa), natDegree_X_pow]
Theorem: ENNReal.ofReal_le_iff_le_toReal
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0∞
hb : b ≠ ⊤
⊢ ENNReal.ofReal a ≤ b ↔ a ≤ b.toReal
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0
⊢ ENNReal.ofReal a ≤ ↑b ↔ a ≤ (↑b).toReal
tactic: lift b to ℝ≥0 using hb
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ
b : ℝ≥0
⊢ ENNReal.ofReal a ≤ ↑b ↔ a ≤ (↑b).toReal
state_after: no goals
tactic: simpa [ENNReal.ofReal, ENNReal.toReal] using Real.toNNReal_le_iff_le_coe
Theorem: NormedSpace.vonNBornology_eq
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ Bornology.vonNBornology 𝕜 E = PseudoMetricSpace.toBornology
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ ∀ (s : Set E), Bornology.IsBounded s ↔ Bornology.IsBounded s
tactic: rw [Bornology.ext_iff_isBounded]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ ∀ (s : Set E), Bornology.IsBounded s ↔ Bornology.IsBounded s
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ Bornology.IsBounded s ↔ Bornology.IsBounded s
tactic: intro s
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ Bornology.IsBounded s ↔ Bornology.IsBounded s
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ Bornology.IsVonNBounded 𝕜 s ↔ Bornology.IsBounded s
tactic: rw [Bornology.isBounded_iff_isVonNBounded]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ Bornology.IsVonNBounded 𝕜 s ↔ Bornology.IsBounded s
state_after: no goals
tactic: exact isVonNBounded_iff _
Theorem: ENNReal.inv_three_add_inv_three
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 3⁻¹ + 3⁻¹ + 3⁻¹ = 3 * 3⁻¹
state_after: no goals
tactic: ring
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 3 ≠ 0
state_after: no goals
tactic: decide
Theorem: AddSubmonoid.closure_pow
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : Semiring R
s : Set R
⊢ closure s ^ 0 = closure (s ^ 0)
state_after: no goals
tactic: rw [pow_zero, pow_zero, one_eq_closure_one_set]
state_before: α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : Semiring R
s : Set R
n : ℕ
⊢ closure s ^ (n + 1) = closure (s ^ (n + 1))
state_after: no goals
tactic: rw [pow_succ, pow_succ, closure_pow s n, closure_mul_closure]
Theorem: Subalgebra.fg_of_fg_toSubmodule
File: Mathlib/RingTheory/Adjoin/FG.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
x✝ : (toSubmodule S).FG
t : Finset A
ht : span R ↑t = toSubmodule S
x : A
hx : x ∈ toSubmodule S
⊢ x ∈ span R ↑t
state_after: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
x✝ : (toSubmodule S).FG
t : Finset A
ht : span R ↑t = toSubmodule S
x : A
hx : x ∈ toSubmodule S
⊢ x ∈ toSubmodule S
tactic: rw [ht]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
x✝ : (toSubmodule S).FG
t : Finset A
ht : span R ↑t = toSubmodule S
x : A
hx : x ∈ toSubmodule S
⊢ x ∈ toSubmodule S
state_after: no goals
tactic: exact hx
Theorem: Opposite.unop_injective
File: Mathlib/Data/Opposite.lean

Proof steps:
state_before: α : Sort u
x✝¹ x✝ : αᵒᵖ
unop✝¹ unop✝ : α
⊢ unop (op unop✝¹) = unop (op unop✝) → op unop✝¹ = op unop✝
state_after: no goals
tactic: simp
Theorem: PartialHomeomorph.restrContDiff_source
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : PartialHomeomorph E F
n : ℕ
x : E
hx : x ∈ f.source
⊢ ↑f x ∈ {y | ContDiffAt 𝕜 (↑n) (↑f.symm) y ∧ ContDiffAt 𝕜 (↑n) (↑f) (↑f.symm y)} ↔
    x ∈ {x | ContDiffAt 𝕜 (↑n) (↑f) x ∧ ContDiffAt 𝕜 (↑n) (↑f.symm) (↑f x)}
state_after: no goals
tactic: simp [hx, and_comm]
Theorem: PrimeMultiset.factorMultiset_prod
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: v : PrimeMultiset
⊢ v.prod.factorMultiset = v
state_after: case a
v : PrimeMultiset
⊢ Coe.coe v.prod.factorMultiset = Coe.coe v
tactic: apply PrimeMultiset.coeNat_injective
state_before: case a
v : PrimeMultiset
⊢ Coe.coe v.prod.factorMultiset = Coe.coe v
state_after: case a
v : PrimeMultiset
⊢ v.prod.factorMultiset.toNatMultiset = v.toNatMultiset
tactic: suffices toNatMultiset (PNat.factorMultiset (prod v)) = toNatMultiset v by exact this
state_before: case a
v : PrimeMultiset
⊢ v.prod.factorMultiset.toNatMultiset = v.toNatMultiset
state_after: case a
v : PrimeMultiset
⊢ ↑v.toNatMultiset.prod.primeFactorsList = v.toNatMultiset
tactic: rw [v.prod.coeNat_factorMultiset, PrimeMultiset.coe_prod]
state_before: case a
v : PrimeMultiset
⊢ ↑v.toNatMultiset.prod.primeFactorsList = v.toNatMultiset
state_after: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(toNatMultiset (Quot.mk Setoid.r l)).prod.primeFactorsList = toNatMultiset (Quot.mk Setoid.r l)
tactic: rcases v with ⟨l⟩
state_before: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(toNatMultiset (Quot.mk Setoid.r l)).prod.primeFactorsList = toNatMultiset (Quot.mk Setoid.r l)
state_after: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(↑(List.map Coe.coe l)).prod.primeFactorsList = ↑(List.map Coe.coe l)
tactic: dsimp [PrimeMultiset.toNatMultiset]
state_before: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(↑(List.map Coe.coe l)).prod.primeFactorsList = ↑(List.map Coe.coe l)
state_after: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
tactic: rw [Multiset.prod_coe]
state_before: case a.mk
v : PrimeMultiset
l : List Nat.Primes
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
state_after: case a.mk
v : PrimeMultiset
l : List Nat.Primes
l' : List ℕ := List.map Coe.coe l
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
tactic: let l' := l.map (Coe.coe : Nat.Primes → ℕ)
state_before: case a.mk
v : PrimeMultiset
l : List Nat.Primes
l' : List ℕ := List.map Coe.coe l
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
state_after: case a.mk
v : PrimeMultiset
l : List Nat.Primes
l' : List ℕ := List.map Coe.coe l
this : ∀ p ∈ l', Nat.Prime p
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
tactic: have : ∀ p : ℕ, p ∈ l' → p.Prime := fun p hp => by
    rcases List.mem_map.mp hp with ⟨⟨_, hp'⟩, ⟨_, h_eq⟩⟩
    exact h_eq ▸ hp'
state_before: case a.mk
v : PrimeMultiset
l : List Nat.Primes
l' : List ℕ := List.map Coe.coe l
this : ∀ p ∈ l', Nat.Prime p
⊢ ↑(List.map Coe.coe l).prod.primeFactorsList = ↑(List.map Coe.coe l)
state_after: no goals
tactic: exact Multiset.coe_eq_coe.mpr (@Nat.primeFactorsList_unique _ l' rfl this).symm
Theorem: Polynomial.expand_zero
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ (expand R 0) f = C (eval 1 f)
state_after: no goals
tactic: simp [expand]
Theorem: finRotate_succ_eq_decomposeFin
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
⊢ finRotate n.succ = decomposeFin.symm (1, finRotate n)
state_after: case H.h
n : ℕ
i : Fin n.succ
⊢ ↑((finRotate n.succ) i) = ↑((decomposeFin.symm (1, finRotate n)) i)
tactic: ext i
state_before: case H.h
n : ℕ
i : Fin n.succ
⊢ ↑((finRotate n.succ) i) = ↑((decomposeFin.symm (1, finRotate n)) i)
state_after: case H.h.zero
i : Fin (Nat.succ 0)
⊢ ↑((finRotate (Nat.succ 0)) i) = ↑((decomposeFin.symm (1, finRotate 0)) i)

case H.h.succ
n✝ : ℕ
i : Fin (n✝ + 1).succ
⊢ ↑((finRotate (n✝ + 1).succ) i) = ↑((decomposeFin.symm (1, finRotate (n✝ + 1))) i)
tactic: cases n
state_before: case H.h.succ
n✝ : ℕ
i : Fin (n✝ + 1).succ
⊢ ↑((finRotate (n✝ + 1).succ) i) = ↑((decomposeFin.symm (1, finRotate (n✝ + 1))) i)
state_after: case H.h.succ.refine_1
n✝ : ℕ
i : Fin (n✝ + 1).succ
⊢ ↑((finRotate (n✝ + 1).succ) 0) = ↑((decomposeFin.symm (1, finRotate (n✝ + 1))) 0)

case H.h.succ.refine_2
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
⊢ ↑((finRotate (n✝ + 1).succ) i.succ) = ↑((decomposeFin.symm (1, finRotate (n✝ + 1))) i.succ)
tactic: refine Fin.cases ?_ (fun i => ?_) i
state_before: case H.h.succ.refine_2
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
⊢ ↑((finRotate (n✝ + 1).succ) i.succ) = ↑((decomposeFin.symm (1, finRotate (n✝ + 1))) i.succ)
state_after: case H.h.succ.refine_2
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
⊢ (if i = Fin.last n✝ then 0 else ↑i.succ + 1) = ↑((swap 0 1) ((finRotate (n✝ + 1)) i).succ)
tactic: rw [coe_finRotate, decomposeFin_symm_apply_succ, if_congr i.succ_eq_last_succ rfl rfl]
state_before: case H.h.succ.refine_2
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
⊢ (if i = Fin.last n✝ then 0 else ↑i.succ + 1) = ↑((swap 0 1) ((finRotate (n✝ + 1)) i).succ)
state_after: case pos
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
h : i = Fin.last n✝
⊢ 0 = ↑((swap 0 1) ((finRotate (n✝ + 1)) i).succ)

case neg
n✝ : ℕ
i✝ : Fin (n✝ + 1).succ
i : Fin (n✝ + 1)
h : ¬i = Fin.last n✝
⊢ ↑i.succ + 1 = ↑((swap 0 1) ((finRotate (n✝ + 1)) i).succ)
tactic: split_ifs with h
Theorem: SatisfiesM_StateT_eq
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α ρ : Type u_1
p : α → Prop
x : StateT ρ m α
inst✝¹ : Monad m
inst✝ : LawfulMonad m
⊢ SatisfiesM p x ↔ ∀ (s : ρ), SatisfiesM (fun x => p x.fst) (x s)
state_after: case refine_1
m : Type u_1 → Type u_2
α ρ : Type u_1
p : α → Prop
x : StateT ρ m α
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x✝ : SatisfiesM p x
f : StateT ρ m { a // p a }
eq : Subtype.val <$> f = x
⊢ ∃ f_1, ∀ (x : ρ), Subtype.val <$> f_1 x = (Subtype.val <$> f) x

case refine_2
m : Type u_1 → Type u_2
α ρ : Type u_1
p : α → Prop
x : StateT ρ m α
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x✝ : ∃ f, ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1
f : ρ → m { a // (fun x => p x.fst) a }
h : ∀ (x_1 : ρ), Subtype.val <$> f x_1 = x x_1
⊢ SatisfiesM p x
tactic: refine .trans ⟨fun ⟨f, eq⟩ => eq ▸ ?_, fun ⟨f, h⟩ => ?_⟩ Classical.skolem.symm
Theorem: singleton_sub_ball_zero
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / ball 1 δ = ball x δ
state_after: no goals
tactic: rw [singleton_div_ball, div_one]
Theorem: Trivialization.preimageSingletonHomeomorph_symm_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x : Z
b : B
hb : b ∈ e.baseSet
p : F
⊢ ↑e.symm (b, p) ∈ proj ⁻¹' {b}
state_after: no goals
tactic: rw [mem_preimage, e.proj_symm_apply' hb, mem_singleton_iff]
Theorem: padicNormE.mul
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ‖q * r‖ = ‖q‖ * ‖r‖
state_after: no goals
tactic: simp [Norm.norm, map_mul]
Theorem: MeasureTheory.integral_average
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ✝ ν : Measure α
s t : Set α
f✝ g : α → E
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → E
⊢ ∫ (x : α), ⨍ (a : α), f a ∂μ ∂μ = ∫ (x : α), f x ∂μ
state_after: no goals
tactic: simp
Theorem: mod_card_zsmul
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n✝ : ℕ
a : G
n : ℤ
⊢ a ^ (n % ↑(card G)) = a ^ n
state_after: no goals
tactic: rw [eq_comm, ← zpow_mod_orderOf, ← Int.emod_emod_of_dvd n
    (Int.natCast_dvd_natCast.2 orderOf_dvd_card), zpow_mod_orderOf]
Theorem: EReal.exp_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

Proof steps:
state_before: x : EReal
⊢ x.exp = 0 ↔ x = ⊥
state_after: no goals
tactic: induction x <;> simp [Real.exp_pos]
Theorem: Ordinal.mod_eq_zero_of_dvd
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
a b : Ordinal.{u_4}
H : b ∣ a
⊢ a % b = 0
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
⊢ b * c % b = 0
tactic: rcases H with ⟨c, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
⊢ b * c % b = 0
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Ordinal.{u_4}
⊢ 0 * c % 0 = 0

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal.{u_4}
hb : b ≠ 0
⊢ b * c % b = 0
tactic: rcases eq_or_ne b 0 with (rfl | hb)
Theorem: Set.Subsingleton.maximals_eq
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
h : s.Subsingleton
⊢ maximals r s = s
state_after: case inl
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
t : Set α
a b x : α
h : ∅.Subsingleton
⊢ maximals r ∅ = ∅

case inr.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
t : Set α
a b x✝ x : α
h : {x}.Subsingleton
⊢ maximals r {x} = {x}
tactic: rcases h.eq_empty_or_singleton with (rfl | ⟨x, rfl⟩)
state_before: case inl
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
t : Set α
a b x : α
h : ∅.Subsingleton
⊢ maximals r ∅ = ∅

case inr.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
t : Set α
a b x✝ x : α
h : {x}.Subsingleton
⊢ maximals r {x} = {x}
state_after: no goals
tactic: exacts [minimals_empty _, maximals_singleton _ _]
Theorem: Lagrange.nodal_empty
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
⊢ nodal ∅ v = 1
state_after: no goals
tactic: rfl
Theorem: continuousOn_prod_of_discrete_right
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
⊢ ContinuousOn f s ↔ ∀ (b : β), ContinuousOn (fun x => f (x, b)) {a | (a, b) ∈ s}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
⊢ (∀ (a : α) (b : β), (a, b) ∈ s → ContinuousWithinAt (fun x => f (x, b)) {a | (a, b) ∈ s} a) ↔
    ∀ (b : β), ∀ x ∈ {a | (a, b) ∈ s}, ContinuousWithinAt (fun x => f (x, b)) {a | (a, b) ∈ s} x
tactic: simp_rw [ContinuousOn, Prod.forall, continuousWithinAt_prod_of_discrete_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
⊢ (∀ (a : α) (b : β), (a, b) ∈ s → ContinuousWithinAt (fun x => f (x, b)) {a | (a, b) ∈ s} a) ↔
    ∀ (b : β), ∀ x ∈ {a | (a, b) ∈ s}, ContinuousWithinAt (fun x => f (x, b)) {a | (a, b) ∈ s} x
state_after: no goals
tactic: apply forall_swap
Theorem: Polynomial.mem_lifts_iff_mem_alg
File: Mathlib/Algebra/Polynomial/Lifts.lean

Proof steps:
state_before: R✝ : Type u
inst✝⁵ : CommSemiring R✝
S✝ : Type v
inst✝⁴ : Semiring S✝
inst✝³ : Algebra R✝ S✝
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : Semiring S
inst✝ : Algebra R S
p : S[X]
⊢ p ∈ lifts (algebraMap R S) ↔ p ∈ (mapAlg R S).range
state_after: no goals
tactic: simp only [coe_mapRingHom, lifts, mapAlg_eq_map, AlgHom.mem_range, RingHom.mem_rangeS]
Theorem: MeasureTheory.laverage_eq_lintegral
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsProbabilityMeasure μ
f : α → ℝ≥0∞
⊢ ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ
state_after: no goals
tactic: rw [laverage, measure_univ, inv_one, one_smul]
Theorem: Complex.sin_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ Real.sin x.arg = x.im / abs x
state_after: a x✝ z x : ℂ
⊢ Real.sin
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.im / abs x
tactic: unfold arg
state_before: a x✝ z x : ℂ
⊢ Real.sin
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.im / abs x
state_after: no goals
tactic: split_ifs <;>
    simp [sub_eq_add_neg, arg,
      Real.sin_arcsin (abs_le.1 (abs_im_div_abs_le_one x)).1 (abs_le.1 (abs_im_div_abs_le_one x)).2,
      Real.sin_add, neg_div, Real.arcsin_neg, Real.sin_neg]
Theorem: Polynomial.leadingCoeff_add_of_degree_lt'
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ (p + q).leadingCoeff = p.leadingCoeff
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ (q + p).leadingCoeff = p.leadingCoeff
tactic: rw [add_comm]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ (q + p).leadingCoeff = p.leadingCoeff
state_after: no goals
tactic: exact leadingCoeff_add_of_degree_lt h