ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.Sorted.rel_get_of_le
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a b : Fin l.length
hab : a ≤ b
⊢ r (l.get a) (l.get b)
state_after: case inl
α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a : Fin l.length
hab : a ≤ a
⊢ r (l.get a) (l.get a)

case inr
α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a b : Fin l.length
hab : a ≤ b
hlt : a < b
⊢ r (l.get a) (l.get b)
tactic: obtain rfl | hlt := Fin.eq_or_lt_of_le hab
state_before: case inl
α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a : Fin l.length
hab : a ≤ a
⊢ r (l.get a) (l.get a)

case inr
α : Type u
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a b : Fin l.length
hab : a ≤ b
hlt : a < b
⊢ r (l.get a) (l.get b)
state_after: no goals
tactic: exacts [refl _, h.rel_get_of_lt hlt]
Theorem: Finsupp.ext_iff'
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ x ∈ f.support, f x = g x
h₁ : f.support = g.support
h₂ : ∀ x ∈ f.support, f x = g x
a : α
⊢ f a = g a
state_after: no goals
tactic: classical
      exact if h : a ∈ f.support then h₂ a h else by
        have hf : f a = 0 := not_mem_support_iff.1 h
        have hg : g a = 0 := by rwa [h₁, not_mem_support_iff] at h
        rw [hf, hg]
Theorem: Int.ModEq.pow
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m✝ n a b c d : ℤ
m : ℕ
h : a ≡ b [ZMOD n]
⊢ a ^ m ≡ b ^ m [ZMOD n]
state_after: case zero
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ a ^ 0 ≡ b ^ 0 [ZMOD n]

case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a ^ (d + 1) ≡ b ^ (d + 1) [ZMOD n]
tactic: induction' m with d hd
state_before: case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a ^ (d + 1) ≡ b ^ (d + 1) [ZMOD n]
state_after: case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a ^ d * a ≡ b ^ d * b [ZMOD n]
tactic: rw [pow_succ, pow_succ]
state_before: case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a ^ d * a ≡ b ^ d * b [ZMOD n]
state_after: no goals
tactic: exact hd.mul h
Theorem: ArithmeticFunction.IsMultiplicative.prodPrimeFactors
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f).IsMultiplicative
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f) 1 = 1 ∧
    ∀ {m n : ℕ},
      m ≠ 0 →
        n ≠ 0 →
          m.Coprime n →
            (ArithmeticFunction.prodPrimeFactors f) (m * n) =
              (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
tactic: rw [iff_ne_zero]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ (ArithmeticFunction.prodPrimeFactors f) 1 = 1 ∧
    ∀ {m n : ℕ},
      m ≠ 0 →
        n ≠ 0 →
          m.Coprime n →
            (ArithmeticFunction.prodPrimeFactors f) (m * n) =
              (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ ∀ {m n : ℕ},
    ¬m = 0 →
      ¬n = 0 →
        m.Coprime n →
          (ArithmeticFunction.prodPrimeFactors f) (m * n) =
            (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
tactic: simp only [ne_eq, one_ne_zero, not_false_eq_true, prodPrimeFactors_apply, primeFactors_one,
    prod_empty, true_and]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
⊢ ∀ {m n : ℕ},
    ¬m = 0 →
      ¬n = 0 →
        m.Coprime n →
          (ArithmeticFunction.prodPrimeFactors f) (m * n) =
            (ArithmeticFunction.prodPrimeFactors f) m * (ArithmeticFunction.prodPrimeFactors f) n
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
tactic: intro x y hx hy hxy
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
state_after: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
hxy₀ : x * y ≠ 0
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
tactic: have hxy₀ : x * y ≠ 0 := mul_ne_zero hx hy
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
f : ℕ → R
x y : ℕ
hx : ¬x = 0
hy : ¬y = 0
hxy : x.Coprime y
hxy₀ : x * y ≠ 0
⊢ (ArithmeticFunction.prodPrimeFactors f) (x * y) =
    (ArithmeticFunction.prodPrimeFactors f) x * (ArithmeticFunction.prodPrimeFactors f) y
state_after: no goals
tactic: rw [prodPrimeFactors_apply hxy₀, prodPrimeFactors_apply hx, prodPrimeFactors_apply hy,
    Nat.primeFactors_mul hx hy, ← Finset.prod_union hxy.disjoint_primeFactors]
Theorem: MeasureTheory.L1.edist_def
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ edist f g = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (if 1 = ⊤ then eLpNormEssSup (↑↑f - ↑↑g) μ else ∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ) =
    ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ
tactic: simp only [Lp.edist_def, eLpNorm, one_ne_zero, eLpNorm', Pi.sub_apply, one_toReal,
    ENNReal.rpow_one, ne_eq, not_false_eq_true, div_self, ite_false]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : ↥(Lp β 1 μ)
⊢ (if 1 = ⊤ then eLpNormEssSup (↑↑f - ↑↑g) μ else ∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ) =
    ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ
state_after: no goals
tactic: simp [edist_eq_coe_nnnorm_sub]
Theorem: EuclideanGeometry.circumradius_eq_of_cospherical_subset
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
⊢ sx₁.circumradius = sx₂.circumradius
state_after: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
⊢ sx₁.circumradius = sx₂.circumradius
tactic: rcases exists_circumradius_eq_of_cospherical_subset h hd hc with ⟨r, hr⟩
state_before: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
sx₁ sx₂ : Simplex ℝ P n
hsx₁ : Set.range sx₁.points ⊆ ps
hsx₂ : Set.range sx₂.points ⊆ ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
⊢ sx₁.circumradius = sx₂.circumradius
state_after: no goals
tactic: rw [hr sx₁ hsx₁, hr sx₂ hsx₂]
Theorem: ack_add_one_sq_lt_ack_add_three
File: Mathlib/Computability/Ackermann.lean

Proof steps:
state_before: n : ℕ
⊢ (ack 0 n + 1) ^ 2 ≤ ack (0 + 3) n
state_after: no goals
tactic: simpa using sq_le_two_pow_add_one_minus_three (n + 2)
state_before: m : ℕ
⊢ (ack (m + 1) 0 + 1) ^ 2 ≤ ack (m + 1 + 3) 0
state_after: m : ℕ
⊢ (ack m 1 + 1) ^ 2 ≤ ack (m + 3) 1
tactic: rw [ack_succ_zero, ack_succ_zero]
state_before: m : ℕ
⊢ (ack m 1 + 1) ^ 2 ≤ ack (m + 3) 1
state_after: no goals
tactic: apply ack_add_one_sq_lt_ack_add_three
state_before: m n : ℕ
⊢ (ack (m + 1) (n + 1) + 1) ^ 2 ≤ ack (m + 1 + 3) (n + 1)
state_after: m n : ℕ
⊢ (ack m (ack (m + 1) n) + 1) ^ 2 ≤ ack (m + 3) (ack (m + 3 + 1) n)
tactic: rw [ack_succ_succ, ack_succ_succ]
state_before: m n : ℕ
⊢ (ack m (ack (m + 1) n) + 1) ^ 2 ≤ ack (m + 3) (ack (m + 3 + 1) n)
state_after: m n : ℕ
⊢ m + 1 ≤ m + 3 + 1
tactic: apply (ack_add_one_sq_lt_ack_add_three _ _).trans (ack_mono_right _ <| ack_mono_left _ _)
state_before: m n : ℕ
⊢ m + 1 ≤ m + 3 + 1
state_after: no goals
tactic: omega
Theorem: frequently_nhdsWithin_iff
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
z : α
s : Set α
p : α → Prop
⊢ (∃ᶠ (x : α) in 𝓝 z, x ∈ s ∧ p x) ↔ ∃ᶠ (x : α) in 𝓝 z, p x ∧ x ∈ s
state_after: no goals
tactic: simp only [and_comm]
Theorem: Real.toNNReal_sum_of_nonneg
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal
state_after: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∑ i ∈ s, f i = ∑ a ∈ s, ↑(f a).toNNReal
tactic: rw [← coe_inj, NNReal.coe_sum, Real.coe_toNNReal _ (Finset.sum_nonneg hf)]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∑ i ∈ s, f i = ∑ a ∈ s, ↑(f a).toNNReal
state_after: no goals
tactic: exact Finset.sum_congr rfl fun x hxs => by rw [Real.coe_toNNReal _ (hf x hxs)]
Theorem: Ordinal.to_leftMoves_one_toPGame_symm
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: i : (toPGame 1).LeftMoves
⊢ toLeftMovesToPGame.symm i = ⟨0, ⋯⟩
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
Theorem: Con.sInf_toSetoid
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ r.Rel x y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ c.Rel x y
tactic: rw [← hr]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
S : Set (Con M)
x y : M
h : (sInf S).Rel x y
r : Setoid M
x✝ : r ∈ toSetoid '' S
c : Con M
hS : c ∈ S
hr : c.toSetoid = r
⊢ c.Rel x y
state_after: no goals
tactic: exact h c hS
Theorem: Cardinal.one_le_iff_pos
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u_1}
⊢ 1 ≤ c ↔ 0 < c
state_after: no goals
tactic: rw [← succ_zero, succ_le_iff]
Theorem: List.sym2_eq_sym_two
File: Mathlib/Data/List/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
xs ys : List α
n : ℕ
⊢ map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
state_after: no goals
tactic: induction xs with
  | nil => simp only [List.sym, map_eq_nil, sym2_eq_nil_iff]
  | cons x xs ih =>
    rw [List.sym, ← ih, sym_one_eq, map_map, List.sym2, map_append, map_map]
    rfl
Theorem: ClassGroup.mk_canonicalEquiv
File: Mathlib/RingTheory/ClassGroup.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_4
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ mk ((Units.map ↑(canonicalEquiv R⁰ K K')) I) = mk I
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_4
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ (QuotientGroup.mk' (toPrincipalIdeal R (FractionRing R)).range)
      ((Units.map ↑(canonicalEquiv R⁰ K (FractionRing R))) I) =
    mk I
tactic: erw [ClassGroup.mk, MonoidHom.comp_apply, ← MonoidHom.comp_apply (Units.map _),
      ← Units.map_comp, ← RingEquiv.coe_monoidHom_trans,
      FractionalIdeal.canonicalEquiv_trans_canonicalEquiv]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_4
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ (QuotientGroup.mk' (toPrincipalIdeal R (FractionRing R)).range)
      ((Units.map ↑(canonicalEquiv R⁰ K (FractionRing R))) I) =
    mk I
state_after: no goals
tactic: rfl
Theorem: LieSubmodule.sup_coe_toSubmodule
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ ↑(N ⊔ N') = ↑N ⊔ ↑N'
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.coequalizer.π_colimMap_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y : C
f g : X ⟶ Y
inst✝¹ : HasCoequalizer f g
X' Y' Z : C
f' g' : X' ⟶ Y'
inst✝ : HasCoequalizer f' g'
p : X ⟶ X'
q : Y ⟶ Y'
wf : f ≫ q = p ≫ f'
wg : g ≫ q = p ≫ g'
h : Y' ⟶ Z
wh : f' ≫ h = g' ≫ h
⊢ π f g ≫ colimMap (parallelPairHom f g f' g' p q wf wg) ≫ desc h wh = q ≫ h
state_after: no goals
tactic: rw [ι_colimMap_assoc, parallelPairHom_app_one, coequalizer.π_desc]
Theorem: MeasureTheory.StronglyMeasurable.integral_kernel_prod_left''
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : γ × β → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun y => ∫ (x : γ), f (x, y) ∂η (a, y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : γ × β → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable ((fun y => ∫ (x : γ), (fun u => f (u.1, u.2.2)) (x, y) ∂η y) ∘ fun x => (a, x))
tactic: change
    StronglyMeasurable
      ((fun y => ∫ x, (fun u : γ × α × β => f (u.1, u.2.2)) (x, y) ∂η y) ∘ fun x => (a, x))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : γ × β → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable ((fun y => ∫ (x : γ), (fun u => f (u.1, u.2.2)) (x, y) ∂η y) ∘ fun x => (a, x))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
E : Type u_4
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : γ × β → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun y => ∫ (x : γ), (fun u => f (u.1, u.2.2)) (x, y) ∂η y
tactic: apply StronglyMeasurable.comp_measurable _ (measurable_prod_mk_left (m := mα))
Theorem: neg_strictConcaveOn_iff
File: Mathlib/Analysis/Convex/Function.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedAddCommGroup β
inst✝¹ : SMul 𝕜 E
inst✝ : Module 𝕜 β
s : Set E
f g : E → β
⊢ StrictConcaveOn 𝕜 s (-f) ↔ StrictConvexOn 𝕜 s f
state_after: no goals
tactic: rw [← neg_strictConvexOn_iff, neg_neg f]
Theorem: PrimeMultiset.coeNat_prime
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: v : PrimeMultiset
p : ℕ
h : p ∈ v.toNatMultiset
⊢ Nat.Prime p
state_after: case intro.mk.intro
v : PrimeMultiset
p : ℕ
h : p ∈ v.toNatMultiset
val✝ : ℕ
hp' : Nat.Prime val✝
left✝ : ⟨val✝, hp'⟩ ∈ v
h_eq : Coe.coe ⟨val✝, hp'⟩ = p
⊢ Nat.Prime p
tactic: rcases Multiset.mem_map.mp h with ⟨⟨_, hp'⟩, ⟨_, h_eq⟩⟩
state_before: case intro.mk.intro
v : PrimeMultiset
p : ℕ
h : p ∈ v.toNatMultiset
val✝ : ℕ
hp' : Nat.Prime val✝
left✝ : ⟨val✝, hp'⟩ ∈ v
h_eq : Coe.coe ⟨val✝, hp'⟩ = p
⊢ Nat.Prime p
state_after: no goals
tactic: exact h_eq ▸ hp'
Theorem: HomologicalComplex.singleObjOpcyclesSelfIso_hom_naturality
File: Mathlib/Algebra/Homology/SingleHomology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : C
f : A ⟶ B
⊢ (singleObjOpcyclesSelfIso c j A).hom ≫ opcyclesMap ((single C c j).map f) j = f ≫ (singleObjOpcyclesSelfIso c j B).hom
state_after: no goals
tactic: rw [← cancel_epi (singleObjCyclesSelfIso c j A).hom,
    singleObjCyclesSelfIso_hom_singleObjOpcyclesSelfIso_hom_assoc, p_opcyclesMap,
    single_map_f_self, assoc, assoc, singleObjCyclesSelfIso_hom,
    singleObjOpcyclesSelfIso_hom, assoc]
Theorem: Int.isUnit_add_isUnit_eq_isUnit_add_isUnit
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v a b c d : ℤ
ha : IsUnit a
hb : IsUnit b
hc : IsUnit c
hd : IsUnit d
⊢ a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c
state_after: u v a b c d : ℤ
ha : a = 1 ∨ a = -1
hb : b = 1 ∨ b = -1
hc : c = 1 ∨ c = -1
hd : d = 1 ∨ d = -1
⊢ a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c
tactic: rw [isUnit_iff] at ha hb hc hd
state_before: u v a b c d : ℤ
ha : a = 1 ∨ a = -1
hb : b = 1 ∨ b = -1
hc : c = 1 ∨ c = -1
hd : d = 1 ∨ d = -1
⊢ a + b = c + d ↔ a = c ∧ b = d ∨ a = d ∧ b = c
state_after: no goals
tactic: cases ha <;> cases hb <;> cases hc <;> cases hd <;>
      subst a <;> subst b <;> subst c <;> subst d <;>
    simp (config := {decide := true})
Theorem: MeasureTheory.sFiniteSeq_absolutelyContinuous_toFiniteAux
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
n : ℕ
⊢ sFiniteSeq μ n ≪ μ.toFiniteAux
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
n : ℕ
⊢ (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ ≠ 0
tactic: refine Measure.absolutelyContinuous_sum_right n (Measure.absolutelyContinuous_smul ?_)
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
n : ℕ
⊢ (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ ≠ 0
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
n : ℕ
⊢ ¬2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ = ⊤
tactic: simp only [ne_eq, ENNReal.inv_eq_zero]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
n : ℕ
⊢ ¬2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ = ⊤
state_after: no goals
tactic: exact ENNReal.mul_ne_top (by simp) (measure_ne_top _ _)
Theorem: Finsupp.single_eq_set_indicator
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
⊢ ⇑(single a b) = {a}.indicator fun x => b
state_after: no goals
tactic: classical
  ext
  simp [single_apply, Set.indicator, @eq_comm _ a]
Theorem: Multiset.mem_inter
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ s ∩ t
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ a ::ₘ s.erase a ∩ t.erase a
tactic: rw [← cons_erase h₁, cons_inter_of_pos _ h₂]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
x✝ : a ∈ s ∧ a ∈ t
h₁ : a ∈ s
h₂ : a ∈ t
⊢ a ∈ a ::ₘ s.erase a ∩ t.erase a
state_after: no goals
tactic: apply mem_cons_self
Theorem: UniqueFactorizationMonoid.multiplicity_eq_count_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ multiplicity a b = ↑(count (normalize a) (normalizedFactors b))
state_after: case a
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ multiplicity a b ≤ ↑(count (normalize a) (normalizedFactors b))

case a
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ ↑(count (normalize a) (normalizedFactors b)) ≤ multiplicity a b
tactic: apply le_antisymm
state_before: case a
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ ↑(count (normalize a) (normalizedFactors b)) ≤ multiplicity a b
state_after: no goals
tactic: rw [le_multiplicity_iff_replicate_le_normalizedFactors ha hb, ← le_count_iff_replicate_le]
Theorem: DFinsupp.filter_apply_pos
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
h : p i
⊢ (filter p f) i = f i
state_after: no goals
tactic: simp only [filter_apply, if_pos h]
Theorem: sub_add_cancel
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c d : G
n : ℤ
a b : G
⊢ a / b * b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, inv_mul_cancel_right a b]