ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.ContinuousOn.hasBoxIntegral
File: Mathlib/Analysis/BoxIntegral/Integrability.lean

Proof steps:
state_before: ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
state_after: case intro
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
tactic: obtain ⟨y, hy⟩ := BoxIntegral.integrable_of_continuousOn l hc μ
state_before: case intro
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
state_after: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
tactic: convert hy
state_before: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
state_after: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
this : IntegrableOn f (↑I) μ
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
tactic: have : IntegrableOn f I μ :=
    IntegrableOn.mono_set (hc.integrableOn_compact I.isCompact_Icc) Box.coe_subset_Icc
state_before: case h.e'_13
ι : Type u
E : Type v
inst✝⁴ : Fintype ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : (ι → ℝ) → E
μ : Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
I : Box ι
hc : ContinuousOn f (Box.Icc I)
l : IntegrationParams
y : E
hy : HasIntegral I l f μ.toBoxAdditive.toSMul y
this : IntegrableOn f (↑I) μ
⊢ ∫ (x : ι → ℝ) in ↑I, f x ∂μ = y
state_after: no goals
tactic: exact HasIntegral.unique (IntegrableOn.hasBoxIntegral this ⊥ rfl) (HasIntegral.mono hy bot_le)
Theorem: padicValNat_factorial_mul_add
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n m : ℕ
hp : Fact (Nat.Prime p)
h : n < p
⊢ padicValNat p (p * m + n)! = padicValNat p (p * m)!
state_after: case zero
p m : ℕ
hp : Fact (Nat.Prime p)
h : 0 < p
⊢ padicValNat p (p * m + 0)! = padicValNat p (p * m)!

case succ
p m : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
hn : n < p → padicValNat p (p * m + n)! = padicValNat p (p * m)!
h : n + 1 < p
⊢ padicValNat p (p * m + (n + 1))! = padicValNat p (p * m)!
tactic: induction' n with n hn
Theorem: Submodule.range_ker_disjoint
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
f : M →ₗ[R] M'
hv : LinearIndependent R (⇑f ∘ v)
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
f : M →ₗ[R] M'
hv : comap (Finsupp.total ι M R v) (LinearMap.ker f) = ⊥
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
tactic: rw [LinearIndependent, Finsupp.total_comp, Finsupp.lmapDomain_total R _ f (fun _ ↦ rfl),
    LinearMap.ker_comp] at hv
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
f : M →ₗ[R] M'
hv : comap (Finsupp.total ι M R v) (LinearMap.ker f) = ⊥
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
state_after: no goals
tactic: rw [disjoint_iff_inf_le, ← Set.image_univ, Finsupp.span_image_eq_map_total,
    map_inf_eq_map_inf_comap, hv, inf_bot_eq, map_bot]
Theorem: memℓp_zero_iff
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ Memℓp f 0 ↔ {i | f i ≠ 0}.Finite
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ (if 0 = 0 then {i | ¬f i = 0}.Finite else Summable fun i => ‖f i‖ ^ 0) ↔ {i | ¬f i = 0}.Finite
tactic: dsimp [Memℓp]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ (if 0 = 0 then {i | ¬f i = 0}.Finite else Summable fun i => ‖f i‖ ^ 0) ↔ {i | ¬f i = 0}.Finite
state_after: no goals
tactic: rw [if_pos rfl]
Theorem: Sum.elim_mul_mul
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Mul γ
⊢ Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b'
state_after: case h
I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Mul γ
x : α ⊕ β
⊢ Sum.elim (a * a') (b * b') x = (Sum.elim a b * Sum.elim a' b') x
tactic: ext x
state_before: case h
I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Mul γ
x : α ⊕ β
⊢ Sum.elim (a * a') (b * b') x = (Sum.elim a b * Sum.elim a' b') x
state_after: no goals
tactic: cases x <;> rfl
Theorem: lt_mul_left
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : PartialOrder α
a b c d : α
inst✝ : MulPosStrictMono α
hn : 0 < a
hm : 1 < b
⊢ a < b * a
state_after: case h.e'_3
α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : PartialOrder α
a b c d : α
inst✝ : MulPosStrictMono α
hn : 0 < a
hm : 1 < b
⊢ a = 1 * a
tactic: convert mul_lt_mul_of_pos_right hm hn
state_before: case h.e'_3
α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : PartialOrder α
a b c d : α
inst✝ : MulPosStrictMono α
hn : 0 < a
hm : 1 < b
⊢ a = 1 * a
state_after: no goals
tactic: rw [one_mul]
Theorem: Padic.norm_eq_pow_val
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
⊢ x ≠ 0 → ‖x‖ = ↑p ^ (-x.valuation)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ‖Quotient.mk'' f‖ = ↑p ^ (-valuation (Quotient.mk'' f))
tactic: refine Quotient.inductionOn' x fun f hf => ?_
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ‖Quotient.mk'' f‖ = ↑p ^ (-valuation (Quotient.mk'' f))
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(PadicSeq.norm f) = ↑p ^ (-PadicSeq.valuation f)
tactic: change (PadicSeq.norm _ : ℝ) = (p : ℝ) ^ (-PadicSeq.valuation _)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(PadicSeq.norm f) = ↑p ^ (-PadicSeq.valuation f)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(↑p ^ (-PadicSeq.valuation f)) = ↑p ^ (-PadicSeq.valuation f)

p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ¬f ≈ 0
tactic: rw [PadicSeq.norm_eq_pow_val]
Theorem: seminormFromBounded_add
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y : R
⊢ seminormFromBounded' f (x + y) ≤ seminormFromBounded' f x + seminormFromBounded' f y
state_after: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
⊢ f ((x + y) * z) / f z ≤ seminormFromBounded' f x + seminormFromBounded' f y
tactic: refine ciSup_le (fun z ↦ ?_)
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
⊢ f ((x + y) * z) / f z ≤ seminormFromBounded' f x + seminormFromBounded' f y
state_after: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
⊢ f ((x + y) * z) / f z ≤ f (x * z) / f z + f (y * z) / f z
tactic: suffices hf : f ((x + y) * z) / f z ≤ f (x * z) / f z + f (y * z) / f z by
    exact le_trans hf (add_le_add
      (le_ciSup_of_le (seminormFromBounded_bddAbove_range f_nonneg f_mul x) z (le_refl _))
      (le_ciSup_of_le (seminormFromBounded_bddAbove_range f_nonneg f_mul y) z (le_refl _)))
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
⊢ f ((x + y) * z) / f z ≤ f (x * z) / f z + f (y * z) / f z
state_after: case pos
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
hz : f z = 0
⊢ f ((x + y) * z) / f z ≤ f (x * z) / f z + f (y * z) / f z

case neg
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
f_add : ∀ (a b : R), f (a + b) ≤ f a + f b
x y z : R
hz : ¬f z = 0
⊢ f ((x + y) * z) / f z ≤ f (x * z) / f z + f (y * z) / f z
tactic: by_cases hz : f z = 0
Theorem: Finset.mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Finset α
a b : α
m : Sym2 α
⊢ m ∈ s.sym2 ↔ ∀ a ∈ m, a ∈ s
state_after: α : Type u_1
β : Type u_2
s t : Finset α
a b : α
m : Sym2 α
⊢ (∀ y ∈ m, y ∈ s.val) ↔ ∀ a ∈ m, a ∈ s
tactic: rw [mem_mk, sym2_val, Multiset.mem_sym2_iff]
state_before: α : Type u_1
β : Type u_2
s t : Finset α
a b : α
m : Sym2 α
⊢ (∀ y ∈ m, y ∈ s.val) ↔ ∀ a ∈ m, a ∈ s
state_after: no goals
tactic: simp only [mem_val]
Theorem: dist_le_tsum_dist_of_tendsto₀
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
h : Summable fun n => dist (f n) (f n.succ)
ha : Tendsto f atTop (𝓝 a)
⊢ dist (f 0) a ≤ ∑' (n : ℕ), dist (f n) (f n.succ)
state_after: no goals
tactic: simpa only [zero_add] using dist_le_tsum_dist_of_tendsto h ha 0
Theorem: MeasureTheory.Integrable.norm_toL1
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 : α → β
hf : Integrable f μ
⊢ ‖toL1 f hf‖ = (∫⁻ (a : α), edist (f a) 0 ∂μ).toReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f μ
⊢ (if 1 = ⊤ then eLpNormEssSup f μ else ∫⁻ (a : α), ↑‖f a‖₊ ∂μ).toReal = (∫⁻ (a : α), edist (f a) 0 ∂μ).toReal
tactic: simp only [toL1, Lp.norm_toLp, eLpNorm, one_ne_zero, eLpNorm', 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 : α → β
hf : Integrable f μ
⊢ (if 1 = ⊤ then eLpNormEssSup f μ else ∫⁻ (a : α), ↑‖f a‖₊ ∂μ).toReal = (∫⁻ (a : α), edist (f a) 0 ∂μ).toReal
state_after: no goals
tactic: simp [edist_eq_coe_nnnorm]
Theorem: preStoneCechCompat
File: Mathlib/Topology/StoneCech.lean

Proof steps:
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
F G : Ultrafilter α
x : α
hF : ↑F ≤ 𝓝 x
hG : ↑G ≤ 𝓝 x
⊢ Ultrafilter.extend g F = Ultrafilter.extend g G
state_after: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
F G : Ultrafilter α
x : α
hG : ↑G ≤ 𝓝 x
hF : map g ↑F ≤ 𝓝 (g x)
⊢ Ultrafilter.extend g F = Ultrafilter.extend g G
tactic: replace hF := (map_mono hF).trans hg.continuousAt
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
F G : Ultrafilter α
x : α
hG : ↑G ≤ 𝓝 x
hF : map g ↑F ≤ 𝓝 (g x)
⊢ Ultrafilter.extend g F = Ultrafilter.extend g G
state_after: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
F G : Ultrafilter α
x : α
hF : map g ↑F ≤ 𝓝 (g x)
hG : map g ↑G ≤ 𝓝 (g x)
⊢ Ultrafilter.extend g F = Ultrafilter.extend g G
tactic: replace hG := (map_mono hG).trans hg.continuousAt
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
F G : Ultrafilter α
x : α
hF : map g ↑F ≤ 𝓝 (g x)
hG : map g ↑G ≤ 𝓝 (g x)
⊢ Ultrafilter.extend g F = Ultrafilter.extend g G
state_after: no goals
tactic: rwa [show Ultrafilter.extend g G = g x by rwa [ultrafilter_extend_eq_iff, G.coe_map],
       ultrafilter_extend_eq_iff, F.coe_map]
Theorem: CategoryTheory.Idempotents.Karoubi.p_comm
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : Karoubi C
f : P.Hom Q
⊢ P.p ≫ f.f = f.f ≫ Q.p
state_after: no goals
tactic: rw [p_comp, comp_p]
Theorem: Real.cauchy_inv
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
f : Cauchy abs
⊢ (Real.inv' { cauchy := f }).cauchy = { cauchy := f }.cauchy⁻¹
state_after: no goals
tactic: rw [inv']
Theorem: Quaternion.tsum_coe
File: Mathlib/Analysis/Quaternion.lean

Proof steps:
state_before: α : Type u_1
f : α → ℝ
⊢ ∑' (a : α), ↑(f a) = ↑(∑' (a : α), f a)
state_after: case pos
α : Type u_1
f : α → ℝ
hf : Summable f
⊢ ∑' (a : α), ↑(f a) = ↑(∑' (a : α), f a)

case neg
α : Type u_1
f : α → ℝ
hf : ¬Summable f
⊢ ∑' (a : α), ↑(f a) = ↑(∑' (a : α), f a)
tactic: by_cases hf : Summable f
Theorem: QuadraticMap.Ring.polar_pi
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁷ : CommRing R
inst✝⁶ : (i : ι) → AddCommGroup (Mᵢ i)
inst✝⁵ : (i : ι) → AddCommGroup (Nᵢ i)
inst✝⁴ : AddCommGroup P
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Module R P
inst✝ : Fintype ι
Q : (i : ι) → QuadraticMap R (Mᵢ i) P
x y : (i : ι) → Mᵢ i
⊢ polar (⇑(pi Q)) x y = ∑ i : ι, polar (⇑(Q i)) (x i) (y i)
state_after: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁷ : CommRing R
inst✝⁶ : (i : ι) → AddCommGroup (Mᵢ i)
inst✝⁵ : (i : ι) → AddCommGroup (Nᵢ i)
inst✝⁴ : AddCommGroup P
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Module R P
inst✝ : Fintype ι
Q : (i : ι) → QuadraticMap R (Mᵢ i) P
x y : (i : ι) → Mᵢ i
⊢ (pi Q) (x + y) - (pi Q) x - (pi Q) y = ∑ i : ι, ((Q i) (x i + y i) - (Q i) (x i) - (Q i) (y i))
tactic: dsimp [polar]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝⁷ : CommRing R
inst✝⁶ : (i : ι) → AddCommGroup (Mᵢ i)
inst✝⁵ : (i : ι) → AddCommGroup (Nᵢ i)
inst✝⁴ : AddCommGroup P
inst✝³ : (i : ι) → Module R (Mᵢ i)
inst✝² : (i : ι) → Module R (Nᵢ i)
inst✝¹ : Module R P
inst✝ : Fintype ι
Q : (i : ι) → QuadraticMap R (Mᵢ i) P
x y : (i : ι) → Mᵢ i
⊢ (pi Q) (x + y) - (pi Q) x - (pi Q) y = ∑ i : ι, ((Q i) (x i + y i) - (Q i) (x i) - (Q i) (y i))
state_after: no goals
tactic: simp_rw [Finset.sum_sub_distrib, pi_apply, Pi.add_apply]
Theorem: Isometry.hausdorffMeasure_image
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set X
⊢ μH[d] (f '' s) = μH[d] s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set X
⊢ ((OuterMeasure.comap f) (OuterMeasure.mkMetric fun r => r ^ d)) s = (OuterMeasure.mkMetric fun r => r ^ d) s
tactic: simp only [hausdorffMeasure, ← OuterMeasure.coe_mkMetric, ← OuterMeasure.comap_apply]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set X
⊢ ((OuterMeasure.comap f) (OuterMeasure.mkMetric fun r => r ^ d)) s = (OuterMeasure.mkMetric fun r => r ^ d) s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set X
⊢ 0 ≤ d → Monotone fun r => r ^ d
tactic: rw [OuterMeasure.isometry_comap_mkMetric _ hf (hd.imp_left _)]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set X
⊢ 0 ≤ d → Monotone fun r => r ^ d
state_after: no goals
tactic: exact ENNReal.monotone_rpow_of_nonneg
Theorem: Int.ModEq.add_left_cancel
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
⊢ d - c = b + d - (a + c) - (b - a)
state_after: no goals
tactic: abel
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
this : d - c = b + d - (a + c) - (b - a)
⊢ n ∣ d - c
state_after: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
this : d - c = b + d - (a + c) - (b - a)
⊢ n ∣ b + d - (a + c) - (b - a)
tactic: rw [this]
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
this : d - c = b + d - (a + c) - (b - a)
⊢ n ∣ b + d - (a + c) - (b - a)
state_after: no goals
tactic: exact dvd_sub h₂.dvd h₁.dvd
Theorem: t2_separation_compact_nhds
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : LocallyCompactSpace X
inst✝ : T2Space X
x y : X
h : x ≠ y
⊢ ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ IsCompact u ∧ IsCompact v ∧ Disjoint u v
state_after: no goals
tactic: simpa only [exists_prop, ← exists_and_left, and_comm, and_assoc, and_left_comm] using
    ((compact_basis_nhds x).disjoint_iff (compact_basis_nhds y)).1 (disjoint_nhds_nhds.2 h)
Theorem: Function.Antiperiodic.sub_const
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : Neg β
h : Antiperiodic f c
a : α
⊢ Antiperiodic (fun x => f (x - a)) c
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h.add_const (-a)
Theorem: Nat.chineseRemainderOfMultiset_lt_prod
File: Mathlib/Data/Nat/ChineseRemainder.lean

Proof steps:
state_before: ι : Type u_1
a s : ι → ℕ
m : Multiset ι
nod : m.Nodup
hs : ∀ i ∈ m, s i ≠ 0
pp : {x | x ∈ m}.Pairwise (Coprime on s)
⊢ ↑(chineseRemainderOfMultiset a s nod hs pp) < (Multiset.map s m).prod
state_after: case mk
ι : Type u_1
a s : ι → ℕ
l : List ι
nod : Multiset.Nodup (Quot.mk Setoid.r l)
hs : ∀ i ∈ Quot.mk Setoid.r l, s i ≠ 0
pp : {x | x ∈ Quot.mk Setoid.r l}.Pairwise (Coprime on s)
⊢ ↑(chineseRemainderOfMultiset a s nod hs pp) < (Multiset.map s (Quot.mk Setoid.r l)).prod
tactic: induction' m using Quot.ind with l
state_before: case mk
ι : Type u_1
a s : ι → ℕ
l : List ι
nod : Multiset.Nodup (Quot.mk Setoid.r l)
hs : ∀ i ∈ Quot.mk Setoid.r l, s i ≠ 0
pp : {x | x ∈ Quot.mk Setoid.r l}.Pairwise (Coprime on s)
⊢ ↑(chineseRemainderOfMultiset a s nod hs pp) < (Multiset.map s (Quot.mk Setoid.r l)).prod
state_after: case mk
ι : Type u_1
a s : ι → ℕ
l : List ι
nod : Multiset.Nodup (Quot.mk Setoid.r l)
hs : ∀ i ∈ Quot.mk Setoid.r l, s i ≠ 0
pp : {x | x ∈ Quot.mk Setoid.r l}.Pairwise (Coprime on s)
⊢ ↑(Quotient.recOn (motive := fun x =>
        x.Nodup → (∀ i ∈ x, s i ≠ 0) → {x_1 | x_1 ∈ x}.Pairwise (Coprime on s) → { k // ∀ i ∈ x, k ≡ a i [MOD s i] })
        (Quot.mk Setoid.r l) (fun l nod x co => chineseRemainderOfList a s l ⋯) ⋯ nod hs pp) <
    (Multiset.map s (Quot.mk Setoid.r l)).prod
tactic: unfold chineseRemainderOfMultiset
state_before: case mk
ι : Type u_1
a s : ι → ℕ
l : List ι
nod : Multiset.Nodup (Quot.mk Setoid.r l)
hs : ∀ i ∈ Quot.mk Setoid.r l, s i ≠ 0
pp : {x | x ∈ Quot.mk Setoid.r l}.Pairwise (Coprime on s)
⊢ ↑(Quotient.recOn (motive := fun x =>
        x.Nodup → (∀ i ∈ x, s i ≠ 0) → {x_1 | x_1 ∈ x}.Pairwise (Coprime on s) → { k // ∀ i ∈ x, k ≡ a i [MOD s i] })
        (Quot.mk Setoid.r l) (fun l nod x co => chineseRemainderOfList a s l ⋯) ⋯ nod hs pp) <
    (Multiset.map s (Quot.mk Setoid.r l)).prod
state_after: no goals
tactic: simpa using chineseRemainderOfList_lt_prod a s l
    (List.Nodup.pairwise_of_forall_ne nod pp) (by simpa using hs)
Theorem: Fin.prod_univ_get'
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
l : List α
f : α → β
⊢ ∏ i : Fin l.length, f l[↑i] = (List.map f l).prod
state_after: no goals
tactic: simp [Finset.prod_eq_multiset_prod]
Theorem: SimpleGraph.adj_replaceVertex_iff_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Operations.lean

Proof steps:
state_before: V : Type u_1
inst✝ : DecidableEq V
G : SimpleGraph V
s t v w : V
hv : v ≠ t
hw : w ≠ t
⊢ (G.replaceVertex s t).Adj v w ↔ G.Adj v w
state_after: no goals
tactic: simp [replaceVertex, hv, hw]