ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: hasFPowerSeriesWithinAt_univ
File: Mathlib/Analysis/Analytic/Within.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
f : E → F
p : FormalMultilinearSeries 𝕜 E F
x : E
⊢ HasFPowerSeriesWithinAt f p univ x ↔ HasFPowerSeriesAt f p x
state_after: no goals
tactic: simp only [HasFPowerSeriesWithinAt, hasFPowerSeriesWithinOnBall_univ, HasFPowerSeriesAt]
Theorem: IsLocalization.sec_spec'
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
z : S
⊢ (algebraMap R S) (sec M z).1 = (algebraMap R S) ↑(sec M z).2 * z
state_after: no goals
tactic: rw [mul_comm, sec_spec]
Theorem: AkraBazziRecurrence.dist_r_b'
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), ‖↑(r i n) - b i * ↑n‖ ≤ ↑n / log ↑n ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2
tactic: rw [Filter.eventually_all]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2
tactic: intro i
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2
state_after: no goals
tactic: simpa using IsLittleO.eventuallyLE (R.dist_r_b i)
Theorem: bihimp_of_ge
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a ⇔ b = a ⇨ b
state_after: no goals
tactic: rw [bihimp, himp_eq_top_iff.2 h, top_inf_eq]
Theorem: ringChar.Nat.cast_ringChar
File: Mathlib/Algebra/CharP/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
⊢ ↑(ringChar R) = 0
state_after: no goals
tactic: rw [ringChar.spec]
Theorem: sdiff_sup_cancel
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : b ≤ a
⊢ a \ b ⊔ b = a
state_after: no goals
tactic: rw [sup_comm, sup_sdiff_cancel_right h]
Theorem: WeierstrassCurve.Affine.nonsingular_neg_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Nonsingular x (W.negY x y) ↔ W.Nonsingular x y
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ∧ (W.a₁ * W.negY x y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ W.negY x y) ↔
    W.Equation x y ∧ (W.a₁ * y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ -y - W.a₁ * x - W.a₃)
tactic: rw [nonsingular_iff, equation_neg_iff, ← negY, negY_negY, ← @ne_comm _ y, nonsingular_iff]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ∧ (W.a₁ * W.negY x y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ W.negY x y) ↔
    W.Equation x y ∧ (W.a₁ * y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ -y - W.a₁ * x - W.a₃)
state_after: no goals
tactic: exact and_congr_right' <| (iff_congr not_and_or.symm not_and_or.symm).mpr <|
    not_congr <| and_congr_left fun h => by rw [← h]
Theorem: continuous_boolIndicator_iff_isClopen
File: Mathlib/Topology/Clopen.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t U : Set X
⊢ Continuous U.boolIndicator ↔ IsClopen U
state_after: no goals
tactic: rw [continuous_bool_rng true, preimage_boolIndicator_true]
Theorem: PFunctor.M.isubtree_cons
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
ps : Path F
a : F.A
f : F.B a → F.M
i : F.B a
⊢ isubtree (⟨a, i⟩ :: ps) (M.mk ⟨a, f⟩) = isubtree ps (f i)
state_after: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
ps : Path F
a : F.A
f : F.B a → F.M
i : F.B a
⊢ isubtree ps (f (cast ⋯ i)) = isubtree ps (f i)
tactic: simp only [isubtree, ichildren_mk, PFunctor.Obj.iget, dif_pos, isubtree, M.casesOn_mk']
state_before: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
ps : Path F
a : F.A
f : F.B a → F.M
i : F.B a
⊢ isubtree ps (f (cast ⋯ i)) = isubtree ps (f i)
state_after: no goals
tactic: rfl
Theorem: Int.two_mul_ediv_two_add_one_of_odd
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ Odd n → 2 * (n / 2) + 1 = n
state_after: case intro
m c : ℤ
⊢ 2 * ((2 * c + 1) / 2) + 1 = 2 * c + 1
tactic: rintro ⟨c, rfl⟩
state_before: case intro
m c : ℤ
⊢ 2 * ((2 * c + 1) / 2) + 1 = 2 * c + 1
state_after: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1
tactic: rw [mul_comm]
state_before: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1
state_after: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2
tactic: convert Int.ediv_add_emod' (2 * c + 1) 2
state_before: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2
state_after: no goals
tactic: simp [Int.add_emod]
Theorem: AddSubsemigroup.dense_induction
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
mul : ∀ (x y : M), p x → p y → p (x * y)
⊢ p x
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x
tactic: have : ∀ x ∈ closure s, p x := fun x hx => closure_induction hx mem mul
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x
state_after: no goals
tactic: simpa [hs] using this x
Theorem: IsTensorProduct.lift_eq
File: Mathlib/RingTheory/IsTensorProduct.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (h.lift f') ((f x₁) x₂) = (f' x₁) x₂
state_after: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (TensorProduct.lift f' ∘ₗ ↑h.equiv.symm) ((f x₁) x₂) = (f' x₁) x₂
tactic: delta IsTensorProduct.lift
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (TensorProduct.lift f' ∘ₗ ↑h.equiv.symm) ((f x₁) x₂) = (f' x₁) x₂
state_after: no goals
tactic: simp
Theorem: Orientation.oangle_add_oangle_rev_neg_right
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
⊢ o.oangle x (-y) + o.oangle y (-x) = 0
state_after: no goals
tactic: rw [o.oangle_rev (-x), oangle_neg_left_eq_neg_right, add_neg_self]
Theorem: Filter.bind_smallSets_gc
File: Mathlib/Order/Filter/SmallSets.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ GaloisConnection (fun L => L.bind 𝓟) smallSets
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb : Filter β
L : Filter (Set α)
l : Filter α
⊢ (fun L => L.bind 𝓟) L ≤ l ↔ L ≤ l.smallSets
tactic: intro L l
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb : Filter β
L : Filter (Set α)
l : Filter α
⊢ (fun L => L.bind 𝓟) L ≤ l ↔ L ≤ l.smallSets
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb : Filter β
L : Filter (Set α)
l : Filter α
⊢ L.bind 𝓟 ≤ l ↔ l.sets ⊆ powerset ⁻¹' L.sets
tactic: simp_rw [smallSets_eq_generate, le_generate_iff, image_subset_iff]
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l✝ l' la : Filter α
lb : Filter β
L : Filter (Set α)
l : Filter α
⊢ L.bind 𝓟 ≤ l ↔ l.sets ⊆ powerset ⁻¹' L.sets
state_after: no goals
tactic: rfl
Theorem: absorbent_iff_inv_smul
File: Mathlib/Topology/Bornology/Absorbs.lean

Proof steps:
state_before: G₀ : Type u_1
α : Type u_2
E : Type u_3
inst✝² : GroupWithZero G₀
inst✝¹ : Bornology G₀
inst✝ : MulAction G₀ α
s : Set α
x : α
⊢ Absorbs G₀ s {x} ↔ ∀ᶠ (c : G₀) in cobounded G₀, c⁻¹ • x ∈ s
state_after: no goals
tactic: simp only [absorbs_iff_eventually_cobounded_mapsTo, mapsTo_singleton]
Theorem: Int.ceil_add_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a + 1⌉ = ⌈a⌉ + 1
state_after: no goals
tactic: rw [← ceil_add_int a (1 : ℤ), cast_one]
Theorem: Set.diff_iInter
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set β
t : ι → Set β
⊢ s \ ⋂ i, t i = ⋃ i, s \ t i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set β
t : ι → Set β
⊢ ⋃ i, s ∩ (t i)ᶜ = ⋃ i, s \ t i
tactic: rw [diff_eq, compl_iInter, inter_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set β
t : ι → Set β
⊢ ⋃ i, s ∩ (t i)ᶜ = ⋃ i, s \ t i
state_after: no goals
tactic: rfl
Theorem: Int.dvd_of_dvd_mul_left_of_gcd_one
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : ↑(a.gcd c) = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
tactic: have := gcd_eq_gcd_ab a c
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : ↑(a.gcd c) = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : 1 = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
tactic: simp only [hab, Int.ofNat_zero, Int.ofNat_succ, zero_add] at this
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this : 1 = a * a.gcdA c + c * a.gcdB c
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b
tactic: have : b * a * gcdA a c + b * c * gcdB a c = b := by simp [mul_assoc, ← Int.mul_add, ← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b
state_after: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b * a * a.gcdA c + b * c * a.gcdB c
tactic: rw [← this]
state_before: a b c : ℤ
habc : a ∣ b * c
hab : a.gcd c = 1
this✝ : 1 = a * a.gcdA c + c * a.gcdB c
this : b * a * a.gcdA c + b * c * a.gcdB c = b
⊢ a ∣ b * a * a.gcdA c + b * c * a.gcdB c
state_after: no goals
tactic: exact Int.dvd_add (dvd_mul_of_dvd_left (dvd_mul_left a b) _) (dvd_mul_of_dvd_left habc _)
Theorem: Rat.cast_lt_zero
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ ↑q < 0 ↔ q < 0
state_after: no goals
tactic: norm_cast
Theorem: ProbabilityTheory.Kernel.compProd_add_right
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
⊢ μ ⊗ₖ (κ + η) = μ ⊗ₖ κ + μ ⊗ₖ η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ((μ ⊗ₖ (κ + η)) a) s = ((μ ⊗ₖ κ + μ ⊗ₖ η) a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ((μ ⊗ₖ (κ + η)) a) s = ((μ ⊗ₖ κ + μ ⊗ₖ η) a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (b : β), (κ (a, b)) {c | (b, c) ∈ s} + (η (a, b)) {c | (b, c) ∈ s} ∂μ a =
    ∫⁻ (b : β), (κ (a, b)) {c | (b, c) ∈ s} ∂μ a + ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂μ a
tactic: simp only [compProd_apply _ _ _ hs, coe_add, Pi.add_apply, Measure.coe_add]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (b : β), (κ (a, b)) {c | (b, c) ∈ s} + (η (a, b)) {c | (b, c) ∈ s} ∂μ a =
    ∫⁻ (b : β), (κ (a, b)) {c | (b, c) ∈ s} ∂μ a + ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂μ a
state_after: case h.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ Measurable fun b => (κ (a, b)) {c | (b, c) ∈ s}
tactic: rw [lintegral_add_left]
state_before: case h.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
μ : Kernel α β
κ η : Kernel (α × β) γ
inst✝² : IsSFiniteKernel μ
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ Measurable fun b => (κ (a, b)) {c | (b, c) ∈ s}
state_after: no goals
tactic: exact measurable_kernel_prod_mk_left' hs a
Theorem: MulEquiv.toSingleObjEquiv_inverse_map
File: Mathlib/CategoryTheory/SingleObj.lean

Proof steps:
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ 𝟭 (SingleObj M) = e.toMonoidHom.toFunctor ⋙ e.symm.toMonoidHom.toFunctor
state_after: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (MonoidHom.id M).toFunctor = (e.symm.toMonoidHom.comp e.toMonoidHom).toFunctor
tactic: rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (MonoidHom.id M).toFunctor = (e.symm.toMonoidHom.comp e.toMonoidHom).toFunctor
state_after: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ MonoidHom.id M = e.symm.toMonoidHom.comp e.toMonoidHom
tactic: congr 1
state_before: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ MonoidHom.id M = e.symm.toMonoidHom.comp e.toMonoidHom
state_after: no goals
tactic: aesop_cat
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.symm.toMonoidHom.toFunctor ⋙ e.toMonoidHom.toFunctor = 𝟭 (SingleObj N)
state_after: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (e.toMonoidHom.comp e.symm.toMonoidHom).toFunctor = (MonoidHom.id N).toFunctor
tactic: rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (e.toMonoidHom.comp e.symm.toMonoidHom).toFunctor = (MonoidHom.id N).toFunctor
state_after: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.toMonoidHom.comp e.symm.toMonoidHom = MonoidHom.id N
tactic: congr 1
state_before: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.toMonoidHom.comp e.symm.toMonoidHom = MonoidHom.id N
state_after: no goals
tactic: aesop_cat
Theorem: Multiset.card_pair
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
⊢ card {a, b} = 2
state_after: no goals
tactic: rw [insert_eq_cons, card_cons, card_singleton]
Theorem: Nat.sqrt_eq_zero
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 0
⊢ n.sqrt < 1
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 0
⊢ 0 < 1
tactic: rw [h]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 0
⊢ 0 < 1
state_after: no goals
tactic: decide
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ n = 0 → n.sqrt = 0
state_after: a b c d m k : ℕ
p q : ℕ → Prop
⊢ sqrt 0 = 0
tactic: rintro rfl
state_before: a b c d m k : ℕ
p q : ℕ → Prop
⊢ sqrt 0 = 0
state_after: no goals
tactic: simp
Theorem: Nat.ord_proj_dvd_ord_proj_of_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
⊢ p ^ a.factorization p ∣ p ^ b.factorization p
state_after: case inl
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : ¬Prime p
⊢ p ^ a.factorization p ∣ p ^ b.factorization p

case inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
⊢ p ^ a.factorization p ∣ p ^ b.factorization p
tactic: rcases em' p.Prime with (pp | pp)
state_before: case inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
⊢ p ^ a.factorization p ∣ p ^ b.factorization p
state_after: case inr.inl
a b✝ m n p✝ b : ℕ
hb0 : b ≠ 0
p : ℕ
pp : Prime p
hab : 0 ∣ b
⊢ p ^ (factorization 0) p ∣ p ^ b.factorization p

case inr.inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
ha0 : a ≠ 0
⊢ p ^ a.factorization p ∣ p ^ b.factorization p
tactic: rcases eq_or_ne a 0 with (rfl | ha0)
state_before: case inr.inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
ha0 : a ≠ 0
⊢ p ^ a.factorization p ∣ p ^ b.factorization p
state_after: case inr.inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
ha0 : a ≠ 0
⊢ a.factorization p ≤ b.factorization p
tactic: rw [pow_dvd_pow_iff_le_right pp.one_lt]
state_before: case inr.inr
a✝ b✝ m n p✝ a b : ℕ
hb0 : b ≠ 0
hab : a ∣ b
p : ℕ
pp : Prime p
ha0 : a ≠ 0
⊢ a.factorization p ≤ b.factorization p
state_after: no goals
tactic: exact (factorization_le_iff_dvd ha0 hb0).2 hab p
Theorem: Set.Nontrivial.infsep_exists_of_finite
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Finite ↑s
hs : s.Nontrivial
⊢ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ s.infsep = dist x y
state_after: no goals
tactic: classical
    cases nonempty_fintype s
    simp_rw [hs.infsep_of_fintype]
    rcases Finset.exists_mem_eq_inf' (s := s.offDiag.toFinset) (by simpa) (uncurry dist) with
      ⟨w, hxy, hed⟩
    simp_rw [mem_toFinset] at hxy
    exact ⟨w.fst, hxy.1, w.snd, hxy.2.1, hxy.2.2, hed⟩
Theorem: TopologicalAddGroup.t1Space
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsClosed {1}
x : G
⊢ IsClosed {x}
state_after: no goals
tactic: simpa using isClosedMap_mul_right x _ h
Theorem: norm_div_le_norm_div_add_norm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b c : E
⊢ ‖a / c‖ ≤ ‖a / b‖ + ‖b / c‖
state_after: no goals
tactic: simpa only [dist_eq_norm_div] using dist_triangle a b c
Theorem: Valuation.supp_quot
File: Mathlib/RingTheory/Valuation/Quotient.lean

Proof steps:
state_before: R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v : Valuation R Γ₀
J : Ideal R
hJ : J ≤ v.supp
⊢ (v.onQuot hJ).supp = Ideal.map (Ideal.Quotient.mk J) v.supp
state_after: case a
R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v : Valuation R Γ₀
J : Ideal R
hJ : J ≤ v.supp
⊢ (v.onQuot hJ).supp ≤ Ideal.map (Ideal.Quotient.mk J) v.supp

case a
R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v : Valuation R Γ₀
J : Ideal R
hJ : J ≤ v.supp
⊢ Ideal.map (Ideal.Quotient.mk J) v.supp ≤ (v.onQuot hJ).supp
tactic: apply le_antisymm