ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ideal.fg_of_isUnit
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
inj : Function.Injective ⇑(algebraMap R P)
I : Ideal R
h : IsUnit ↑I
⊢ I.FG
state_after: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
inj : Function.Injective ⇑(algebraMap R P)
I : Ideal R
h : IsUnit ↑I
⊢ (↑↑I).FG
tactic: rw [← coeIdeal_fg S inj I]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
inj : Function.Injective ⇑(algebraMap R P)
I : Ideal R
h : IsUnit ↑I
⊢ (↑↑I).FG
state_after: no goals
tactic: exact FractionalIdeal.fg_of_isUnit I h
Theorem: Monotone.le_map_sSup
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Monotone f
⊢ ⨆ a ∈ s, f a ≤ f (sSup s)
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Monotone f
⊢ ⨆ a ∈ s, f a ≤ f (⨆ a ∈ s, a)
tactic: rw [sSup_eq_iSup]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Monotone f
⊢ ⨆ a ∈ s, f a ≤ f (⨆ a ∈ s, a)
state_after: no goals
tactic: exact hf.le_map_iSup₂ _
Theorem: Prefunctor.bijective_costar_iff_bijective_star
File: Mathlib/Combinatorics/Quiver/Covering.lean

Proof steps:
state_before: U : Type u_1
inst✝⁵ : Quiver U
V : Type u_2
inst✝⁴ : Quiver V
φ : U ⥤q V
W : Type ?u.19860
inst✝³ : Quiver W
ψ : V ⥤q W
inst✝² : HasInvolutiveReverse U
inst✝¹ : HasInvolutiveReverse V
inst✝ : φ.MapReverse
u : U
⊢ Bijective (φ.costar u) ↔ Bijective (φ.star u)
state_after: no goals
tactic: rw [Prefunctor.costar_conj_star φ, EquivLike.comp_bijective, EquivLike.bijective_comp]
Theorem: mul_le_of_one_le_right
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : Preorder α
a b c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : PosMulMono α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
ha : a ≤ 0
h : 1 ≤ b
⊢ a * b ≤ a
state_after: no goals
tactic: simpa only [mul_one] using mul_le_mul_of_nonpos_left h ha
Theorem: CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal_inv
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsTerminal X
⊢ (zeroIsoIsTerminal t).inv = 0
state_after: no goals
tactic: ext
Theorem: ENNReal.ofReal_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
state_after: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : p = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
tactic: by_cases hp0 : p = 0
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
state_after: case pos
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : ¬x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
tactic: by_cases hx0 : x = 0
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : ¬x = 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
state_after: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : x ≠ 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
tactic: rw [← Ne] at hx0
state_before: case neg
x p : ℝ
hx_nonneg : 0 ≤ x
hp_nonneg : 0 ≤ p
hp0 : ¬p = 0
hx0 : x ≠ 0
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
state_after: no goals
tactic: exact ofReal_rpow_of_pos (hx_nonneg.lt_of_ne hx0.symm)
Theorem: intervalIntegral.hasSum_integral_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/DominatedConvergence.lean

Proof steps:
state_before: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
inst✝ : Countable ι
F : ι → ℝ → E
bound : ι → ℝ → ℝ
hF_meas : ∀ (n : ι), AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ (n : ι), ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → ‖F n t‖ ≤ bound n t
bound_summable : ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → Summable fun n => bound n t
bound_integrable : IntervalIntegrable (fun t => ∑' (n : ι), bound n t) μ a b
h_lim : ∀ᵐ (t : ℝ) ∂μ, t ∈ Ι a b → HasSum (fun n => F n t) (f t)
⊢ HasSum (fun n => ∫ (t : ℝ) in a..b, F n t ∂μ) (∫ (t : ℝ) in a..b, f t ∂μ)
state_after: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
inst✝ : Countable ι
F : ι → ℝ → E
bound : ι → ℝ → ℝ
hF_meas : ∀ (n : ι), AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ (n : ι), ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), ‖F n x‖ ≤ bound n x
bound_summable : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), Summable fun n => bound n x
bound_integrable : IntegrableOn (fun t => ∑' (n : ι), bound n t) (Ι a b) μ
h_lim : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), HasSum (fun n => F n x) (f x)
⊢ HasSum (fun n => (if a ≤ b then 1 else -1) • ∫ (t : ℝ) in Ι a b, F n t ∂μ)
    ((if a ≤ b then 1 else -1) • ∫ (t : ℝ) in Ι a b, f t ∂μ)
tactic: simp only [intervalIntegrable_iff, intervalIntegral_eq_integral_uIoc, ←
    ae_restrict_iff' (α := ℝ) (μ := μ) measurableSet_uIoc] at *
state_before: ι✝ : Type u_1
𝕜 : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f : ℝ → E
μ : Measure ℝ
ι : Type u_5
inst✝ : Countable ι
F : ι → ℝ → E
bound : ι → ℝ → ℝ
hF_meas : ∀ (n : ι), AEStronglyMeasurable (F n) (μ.restrict (Ι a b))
h_bound : ∀ (n : ι), ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), ‖F n x‖ ≤ bound n x
bound_summable : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), Summable fun n => bound n x
bound_integrable : IntegrableOn (fun t => ∑' (n : ι), bound n t) (Ι a b) μ
h_lim : ∀ᵐ (x : ℝ) ∂μ.restrict (Ι a b), HasSum (fun n => F n x) (f x)
⊢ HasSum (fun n => (if a ≤ b then 1 else -1) • ∫ (t : ℝ) in Ι a b, F n t ∂μ)
    ((if a ≤ b then 1 else -1) • ∫ (t : ℝ) in Ι a b, f t ∂μ)
state_after: no goals
tactic: exact
    (hasSum_integral_of_dominated_convergence bound hF_meas h_bound bound_summable bound_integrable
          h_lim).const_smul
      _
Theorem: MeasureTheory.OuterMeasure.map_biInf_comap
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
β : Type u_3
I : Set ι
hI : I.Nonempty
f : α → β
m : ι → OuterMeasure β
⊢ (map f) (⨅ i ∈ I, (comap f) (m i)) = ⨅ i ∈ I, (map f) ((comap f) (m i))
state_after: α : Type u_1
ι : Type u_2
β : Type u_3
I : Set ι
hI : I.Nonempty
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ (map f) (⨅ i ∈ I, (comap f) (m i)) = ⨅ i ∈ I, (map f) ((comap f) (m i))
tactic: haveI := hI.to_subtype
state_before: α : Type u_1
ι : Type u_2
β : Type u_3
I : Set ι
hI : I.Nonempty
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ (map f) (⨅ i ∈ I, (comap f) (m i)) = ⨅ i ∈ I, (map f) ((comap f) (m i))
state_after: α : Type u_1
ι : Type u_2
β : Type u_3
I : Set ι
hI : I.Nonempty
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ (map f) (⨅ i, (comap f) (m ↑i)) = ⨅ i, (map f) ((comap f) (m ↑i))
tactic: rw [← iInf_subtype'', ← iInf_subtype'']
state_before: α : Type u_1
ι : Type u_2
β : Type u_3
I : Set ι
hI : I.Nonempty
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ (map f) (⨅ i, (comap f) (m ↑i)) = ⨅ i, (map f) ((comap f) (m ↑i))
state_after: no goals
tactic: exact map_iInf_comap _
Theorem: pow_mod_natCard
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 % Nat.card G) = a ^ n
state_after: no goals
tactic: rw [eq_comm, ← pow_mod_orderOf, ← Nat.mod_mod_of_dvd n $ orderOf_dvd_natCard _, pow_mod_orderOf]
Theorem: Ordinal.principal_add_isLimit
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
⊢ o.IsLimit
state_after: case refine_1
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False

case refine_2
o : Ordinal.{u_1}
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal.{u_1}
hao : a < o
⊢ succ a < o
tactic: refine ⟨fun ho₀ => ?_, fun a hao => ?_⟩
Theorem: Surreal.Multiplication.P3_of_lt
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
h : ∀ (i : x₂.LeftMoves), IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hs : ∀ (i : (-x₁).LeftMoves), IH3 (-x₂) ((-x₁).moveLeft i) (-x₁) y₁ y₂
hl : x₁ < x₂
⊢ P3 x₁ x₂ y₁ y₂
state_after: case inl.intro
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
h : ∀ (i : x₂.LeftMoves), IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hs : ∀ (i : (-x₁).LeftMoves), IH3 (-x₂) ((-x₁).moveLeft i) (-x₁) y₁ y₂
hl : x₁ < x₂
i : x₂.LeftMoves
hi : x₁ ≤ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂

case inr.intro
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
h : ∀ (i : x₂.LeftMoves), IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hs : ∀ (i : (-x₁).LeftMoves), IH3 (-x₂) ((-x₁).moveLeft i) (-x₁) y₁ y₂
hl : x₁ < x₂
i : x₁.RightMoves
hi : x₁.moveRight i ≤ x₂
⊢ P3 x₁ x₂ y₁ y₂
tactic: obtain (⟨i,hi⟩|⟨i,hi⟩) := lf_iff_exists_le.1 (lf_of_lt hl)
Theorem: Set.indicator_image
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → M
g : α → β
hg : Injective g
x : α
⊢ (g '' s).mulIndicator f (g x) = s.mulIndicator (f ∘ g) x
state_after: no goals
tactic: rw [← mulIndicator_comp_right, preimage_image_eq _ hg]
Theorem: IsPrimePow.pow
File: Mathlib/Algebra/IsPrimePow.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n✝ p✝ : R
k✝ : ℕ
n : R
hn✝ : IsPrimePow n
k : ℕ
hk : k ≠ 0
p : R
k' : ℕ
hp : Prime p
hk' : 0 < k'
hn : p ^ k' = n
⊢ p ^ (k * k') = n ^ k
state_after: no goals
tactic: rw [pow_mul', hn]
Theorem: ascPochhammer_nat_eval_succ
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: S : Type u_1
inst✝ : Semiring S
r✝ n r : ℕ
⊢ 0 * eval (0 + 1) (ascPochhammer ℕ r) = (0 + r) * eval 0 (ascPochhammer ℕ r)
state_after: case pos
S : Type u_1
inst✝ : Semiring S
r✝ n r : ℕ
h : r = 0
⊢ 0 * eval (0 + 1) (ascPochhammer ℕ r) = (0 + r) * eval 0 (ascPochhammer ℕ r)

case neg
S : Type u_1
inst✝ : Semiring S
r✝ n r : ℕ
h : ¬r = 0
⊢ 0 * eval (0 + 1) (ascPochhammer ℕ r) = (0 + r) * eval 0 (ascPochhammer ℕ r)
tactic: by_cases h : r = 0
state_before: S : Type u_1
inst✝ : Semiring S
r✝ n r k : ℕ
⊢ (k + 1) * eval (k + 1 + 1) (ascPochhammer ℕ r) = (k + 1 + r) * eval (k + 1) (ascPochhammer ℕ r)
state_after: no goals
tactic: simp only [ascPochhammer_nat_eq_ascFactorial, Nat.succ_ascFactorial, add_right_comm]
Theorem: HasDerivWithinAt.complexToReal_fderiv'
File: Mathlib/Analysis/Complex/RealDeriv.lean

Proof steps:
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
s : Set ℂ
x : ℂ
f' : E
h : HasDerivWithinAt f f' s x
⊢ HasFDerivWithinAt f (reCLM.smulRight f' + I • imCLM.smulRight f') s x
state_after: no goals
tactic: simpa only [Complex.restrictScalars_one_smulRight'] using
    h.hasFDerivWithinAt.restrictScalars ℝ
Theorem: Matrix.cons_vec_bit0_eq_alt0
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (i + i) = vecAlt0 ⋯ (vecAppend ⋯ (vecCons x u) (vecCons x u)) i
state_after: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (i + i) = (vecCons x u ∘ fun n_1 => n_1 + n_1) i
tactic: rw [vecAlt0_vecAppend]
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (i + i) = (vecCons x u ∘ fun n_1 => n_1 + n_1) i
state_after: no goals
tactic: rfl
Theorem: NNReal.eq_rpow_one_div_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y✝ z✝ : ℝ
x y : ℝ≥0
z : ℝ
hz : z ≠ 0
⊢ x = y ^ (1 / z) ↔ x ^ z = y
state_after: no goals
tactic: rw [← rpow_eq_rpow_iff hz, rpow_self_rpow_inv hz]
Theorem: finsum_mem_union'
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hst : Disjoint s t
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ ∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i
state_after: no goals
tactic: rw [← finprod_mem_union_inter' hs ht, disjoint_iff_inter_eq_empty.1 hst, finprod_mem_empty,
    mul_one]
Theorem: isFiniteMeasure_iff_isFiniteMeasureOnCompacts_of_compactSpace
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
⊢ IsFiniteMeasure μ ↔ IsFiniteMeasureOnCompacts μ
state_after: case mp
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasure μ
⊢ IsFiniteMeasureOnCompacts μ

case mpr
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : CompactSpace α
a✝ : IsFiniteMeasureOnCompacts μ
⊢ IsFiniteMeasure μ
tactic: constructor <;> intros
Theorem: AddMonoid.minOrder_eq_top
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a : α
⊢ minOrder α = ⊤ ↔ IsTorsionFree α
state_after: no goals
tactic: simp [minOrder, IsTorsionFree]
Theorem: pow_right_comm
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m✝ n✝ : ℕ
a : M
m n : ℕ
⊢ (a ^ m) ^ n = (a ^ n) ^ m
state_after: no goals
tactic: rw [← pow_mul, Nat.mul_comm, pow_mul]
Theorem: Multiset.sum_map_zero
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
⊢ (map (fun x => 1) m).prod = 1
state_after: no goals
tactic: rw [map_const', prod_replicate, one_pow]
Theorem: Module.isTorsionBy_iff_torsionBy_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ IsTorsionBy R M a ↔ torsionBy R M a = ⊤
state_after: no goals
tactic: rw [← torsionBySet_singleton_eq, ← isTorsionBySet_singleton_iff,
    isTorsionBySet_iff_torsionBySet_eq_top]
Theorem: QuaternionAlgebra.self_add_star'
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a + star a = ↑(2 * a.re)
state_after: no goals
tactic: ext <;> simp [two_mul]
Theorem: Real.deriv_tan_sub_id
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

Proof steps:
state_before: x✝ x : ℝ
h : cos x ≠ 0
⊢ HasDerivAt (fun y => tan y - y) (1 / cos x ^ 2 - 1) x
state_after: no goals
tactic: simpa using (hasDerivAt_tan h).add (hasDerivAt_id x).neg
Theorem: AddSubsemigroup.coe_sSup_of_directed_on
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : Set (Subsemigroup M)
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ s ∈ S, ↑s
state_after: no goals
tactic: simp [mem_sSup_of_directed_on hS]
Theorem: OrderIso.isLUB_image
File: Mathlib/Order/Bounds/OrderIso.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set α
x : β
h : IsLUB (⇑f '' s) x
⊢ ∀ {x y : α}, f x ≤ f y ↔ x ≤ y
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set α
x : β
h : IsLUB s (f.symm x)
⊢ ∀ {x y : β}, f.symm x ≤ f.symm y ↔ x ≤ y
state_after: no goals
tactic: simp
Theorem: List.formPerm_apply_getElem_length
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ (x :: xs).formPerm (x :: xs)[xs.length] = x
state_after: no goals
tactic: rw [getElem_cons_length _ _ _ rfl, formPerm_apply_getLast]
Theorem: FreeGroup.map_eq_lift
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y : FreeGroup α
x : α
⊢ (lift (of ∘ f)) (of x) = of (f x)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.eqToHom_iso_inv_naturality
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ f j = f j'
state_after: no goals
tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ g j = g j'
state_after: no goals
tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ (z j).inv ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j').inv
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j : β
⊢ (z j).inv ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j).inv
tactic: cases w
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j : β
⊢ (z j).inv ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j).inv
state_after: no goals
tactic: simp
Theorem: Finset.exists_le_card_fiber_of_nsmul_le_card_of_maps_to
File: Mathlib/Combinatorics/Pigeonhole.lean

Proof steps:
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ a ∈ s, f a ∈ t
ht : t.Nonempty
hb : t.card • b ≤ ↑s.card
⊢ ∃ y ∈ t, b ≤ ↑(filter (fun x => f x = y) s).card
state_after: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ a ∈ s, f a ∈ t
ht : t.Nonempty
hb : t.card • b ≤ ∑ a ∈ s, 1
⊢ ∃ y ∈ t, b ≤ ∑ a ∈ filter (fun x => f x = y) s, 1
tactic: simp_rw [cast_card] at hb ⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
hf : ∀ a ∈ s, f a ∈ t
ht : t.Nonempty
hb : t.card • b ≤ ∑ a ∈ s, 1
⊢ ∃ y ∈ t, b ≤ ∑ a ∈ filter (fun x => f x = y) s, 1
state_after: no goals
tactic: exact exists_le_sum_fiber_of_maps_to_of_nsmul_le_sum hf ht hb
Theorem: Complex.HadamardThreeLines.sSupNormIm_nonneg
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
x : ℝ
⊢ 0 ≤ sSupNormIm f x
state_after: case hS
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
x : ℝ
⊢ ∀ x_1 ∈ norm ∘ f '' (re ⁻¹' {x}), 0 ≤ x_1
tactic: apply Real.sSup_nonneg
state_before: case hS
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
x : ℝ
⊢ ∀ x_1 ∈ norm ∘ f '' (re ⁻¹' {x}), 0 ≤ x_1
state_after: case hS.intro.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
x y : ℝ
z1 : ℂ
left✝ : z1 ∈ re ⁻¹' {x}
hz2 : (norm ∘ f) z1 = y
⊢ 0 ≤ y
tactic: rintro y ⟨z1, _, hz2⟩
state_before: case hS.intro.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
x y : ℝ
z1 : ℂ
left✝ : z1 ∈ re ⁻¹' {x}
hz2 : (norm ∘ f) z1 = y
⊢ 0 ≤ y
state_after: no goals
tactic: simp only [← hz2, comp, norm_nonneg]