ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MonoidAlgebra.finiteType_iff_group_fg
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝³ : Monoid M
G : Type u_3
inst✝² : Group G
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ FiniteType R (MonoidAlgebra R G) ↔ Group.FG G
state_after: no goals
tactic: simpa [Group.fg_iff_monoid_fg] using finiteType_iff_fg
Theorem: CategoryTheory.ShortComplex.homologyMap'_nullHomotopic
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
H₁ : S₁.HomologyData
H₂ : S₂.HomologyData
h₀ : S₁.X₁ ⟶ S₂.X₁
h₀_f : h₀ ≫ S₂.f = 0
h₁ : S₁.X₂ ⟶ S₂.X₁
h₂ : S₁.X₃ ⟶ S₂.X₂
h₃ : S₁.X₃ ⟶ S₂.X₃
g_h₃ : S₁.g ≫ h₃ = 0
⊢ homologyMap' (S₁.nullHomotopic S₂ h₀ h₀_f h₁ h₂ h₃ g_h₃) H₁ H₂ = 0
state_after: no goals
tactic: apply leftHomologyMap'_nullHomotopic
Theorem: sup_inf_inf_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ z ⊔ y \ z = x ⊓ (y ⊓ z) ⊔ y \ z
state_after: no goals
tactic: rw [inf_assoc]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ (y ⊓ z) ⊔ y \ z = (x ⊔ y \ z) ⊓ y
state_after: no goals
tactic: rw [sup_inf_right, sup_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x ⊔ y \ z) ⊓ y = x ⊓ y ⊔ y \ z
state_after: no goals
tactic: rw [inf_sup_right, inf_sdiff_left]
Theorem: cpow_eq_nhds
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ (fun x => x ^ b) =ᶠ[𝓝 a] fun x => cexp (Complex.log x * b)
state_after: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ ∀ᶠ (x : ℂ) in 𝓝 a, x ≠ 0
tactic: suffices ∀ᶠ x : ℂ in 𝓝 a, x ≠ 0 from
    this.mono fun x hx ↦ by
      dsimp only
      rw [cpow_def_of_ne_zero hx]
state_before: α : Type u_1
a b : ℂ
ha : a ≠ 0
⊢ ∀ᶠ (x : ℂ) in 𝓝 a, x ≠ 0
state_after: no goals
tactic: exact IsOpen.eventually_mem isOpen_ne ha
Theorem: RingHom.pNilradical_le_ker_of_perfectRing
File: Mathlib/FieldTheory/IsPerfectClosure.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝⁶ : CommSemiring K
inst✝⁵ : CommSemiring L
inst✝⁴ : CommSemiring M
i : K →+* L
j : K →+* M
f : L →+* M
p : ℕ
inst✝³ : ExpChar K p
inst✝² : ExpChar L p
inst✝¹ : ExpChar M p
inst✝ : PerfectRing L p
x : K
h : x ∈ pNilradical K p
⊢ x ∈ ker i
state_after: case intro
K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝⁶ : CommSemiring K
inst✝⁵ : CommSemiring L
inst✝⁴ : CommSemiring M
i : K →+* L
j : K →+* M
f : L →+* M
p : ℕ
inst✝³ : ExpChar K p
inst✝² : ExpChar L p
inst✝¹ : ExpChar M p
inst✝ : PerfectRing L p
x : K
h✝ : x ∈ pNilradical K p
n : ℕ
h : x ^ p ^ n = 0
⊢ x ∈ ker i
tactic: obtain ⟨n, h⟩ := mem_pNilradical.1 h
state_before: case intro
K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝⁶ : CommSemiring K
inst✝⁵ : CommSemiring L
inst✝⁴ : CommSemiring M
i : K →+* L
j : K →+* M
f : L →+* M
p : ℕ
inst✝³ : ExpChar K p
inst✝² : ExpChar L p
inst✝¹ : ExpChar M p
inst✝ : PerfectRing L p
x : K
h✝ : x ∈ pNilradical K p
n : ℕ
h : x ^ p ^ n = 0
⊢ x ∈ ker i
state_after: case intro
K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝⁶ : CommSemiring K
inst✝⁵ : CommSemiring L
inst✝⁴ : CommSemiring M
i : K →+* L
j : K →+* M
f : L →+* M
p : ℕ
inst✝³ : ExpChar K p
inst✝² : ExpChar L p
inst✝¹ : ExpChar M p
inst✝ : PerfectRing L p
x : K
h✝ : x ∈ pNilradical K p
n : ℕ
h : (iterateFrobeniusEquiv L p n).symm (i (x ^ p ^ n)) = (iterateFrobeniusEquiv L p n).symm (i 0)
⊢ x ∈ ker i
tactic: replace h := congr((iterateFrobeniusEquiv L p n).symm (i $h))
state_before: case intro
K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝⁶ : CommSemiring K
inst✝⁵ : CommSemiring L
inst✝⁴ : CommSemiring M
i : K →+* L
j : K →+* M
f : L →+* M
p : ℕ
inst✝³ : ExpChar K p
inst✝² : ExpChar L p
inst✝¹ : ExpChar M p
inst✝ : PerfectRing L p
x : K
h✝ : x ∈ pNilradical K p
n : ℕ
h : (iterateFrobeniusEquiv L p n).symm (i (x ^ p ^ n)) = (iterateFrobeniusEquiv L p n).symm (i 0)
⊢ x ∈ ker i
state_after: no goals
tactic: rwa [map_pow, ← iterateFrobenius_def, ← iterateFrobeniusEquiv_apply, RingEquiv.symm_apply_apply,
    map_zero, map_zero] at h
Theorem: CoxeterSystem.not_isLeftDescent_one
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ ¬cs.IsLeftDescent 1 i
state_after: no goals
tactic: simp [IsLeftDescent]
Theorem: CategoryTheory.CosimplicialObject.instCategoryAugmented_comp_right_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Augmented C)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
tactic: dsimp only [Augmented]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
state_after: no goals
tactic: infer_instance
Theorem: exists_signed_sum
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α✝ α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
β : Type u_1
t : Finset β
sgn : β → SignType
g : β → α
hg : ∀ (b : β), g b ∈ s
ht : t.card = ∑ a ∈ s, (f a).natAbs
hf : ∀ a ∈ s, (∑ b ∈ t, if g b = a then ↑(sgn b) else 0) = f a
⊢ Fintype.card { x // x ∈ t } = ∑ a ∈ s, (f a).natAbs
state_after: no goals
tactic: simp [ht]
Theorem: Filter.EventuallyEq.iteratedFDerivWithin_eq
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : f₁ =ᶠ[𝓝[s] x] f
hx : f₁ x = f x
n : ℕ
⊢ f₁ =ᶠ[𝓝[insert x s] x] f
state_after: no goals
tactic: simpa [EventuallyEq, hx]
Theorem: CategoryTheory.Functor.map_comp_heq'
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hobj : ∀ (X : C), F.obj X = G.obj X
hmap : ∀ {X Y : C} (f : X ⟶ Y), HEq (F.map f) (G.map f)
⊢ HEq (F.map (f ≫ g)) (G.map (f ≫ g))
state_after: no goals
tactic: rw [Functor.hext hobj fun _ _ => hmap]
Theorem: String.Iterator.ValidFor.hasPrev
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.hasPrev = true ↔ l ≠ []
state_after: no goals
tactic: simp [Iterator.hasPrev, h.pos, Nat.pos_iff_ne_zero]
Theorem: stdSimplex_subset_closedBall
File: Mathlib/Analysis/Convex/Topology.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
⊢ f ∈ closedBall 0 1
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
⊢ ∀ (b : ι), dist (f b) (0 b) ≤ 1
tactic: rw [Metric.mem_closedBall, dist_pi_le_iff zero_le_one]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
⊢ ∀ (b : ι), dist (f b) (0 b) ≤ 1
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
x : ι
⊢ dist (f x) (0 x) ≤ 1
tactic: intro x
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
x : ι
⊢ dist (f x) (0 x) ≤ 1
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
x : ι
⊢ f x ≤ 1
tactic: rw [Pi.zero_apply, Real.dist_0_eq_abs, abs_of_nonneg <| hf.1 x]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝ : Fintype ι
f : ι → ℝ
hf : f ∈ stdSimplex ℝ ι
x : ι
⊢ f x ≤ 1
state_after: no goals
tactic: exact (mem_Icc_of_mem_stdSimplex hf x).2
Theorem: MeasureTheory.condexp_nonpos
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : NormedSpace 𝕜 F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
E : Type u_5
inst✝³ : NormedLatticeAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
inst✝ : OrderedSMul ℝ E
f : α → E
hf : f ≤ᶠ[ae μ] 0
⊢ μ[f|m] ≤ᶠ[ae μ] 0
state_after: case pos
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : NormedSpace 𝕜 F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
E : Type u_5
inst✝³ : NormedLatticeAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
inst✝ : OrderedSMul ℝ E
f : α → E
hf : f ≤ᶠ[ae μ] 0
hfint : Integrable f μ
⊢ μ[f|m] ≤ᶠ[ae μ] 0

case neg
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
inst✝⁷ : NormedAddCommGroup F'
inst✝⁶ : NormedSpace 𝕜 F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
E : Type u_5
inst✝³ : NormedLatticeAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
inst✝ : OrderedSMul ℝ E
f : α → E
hf : f ≤ᶠ[ae μ] 0
hfint : ¬Integrable f μ
⊢ μ[f|m] ≤ᶠ[ae μ] 0
tactic: by_cases hfint : Integrable f μ
Theorem: antivary_iff_forall_smul_nonpos
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Monovary f (⇑OrderDual.toDual ∘ g) ↔ ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ (∀ (i j : ι), 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0
tactic: rw [monovary_iff_forall_smul_nonneg]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ (∀ (i j : ι), 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0
state_after: no goals
tactic: rfl
Theorem: ContinuousMap.Homotopy.symm_apply
File: Mathlib/Topology/Homotopy/Basic.lean

Proof steps:
state_before: F✝ : Type u_1
X : Type u
Y : Type v
Z : Type w
Z' : Type x
ι : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : f₀.Homotopy f₁
⊢ ∀ (x : X), { toFun := fun x => F (σ x.1, x.2), continuous_toFun := ⋯ }.toFun (0, x) = f₁ x
state_after: no goals
tactic: norm_num
state_before: F✝ : Type u_1
X : Type u
Y : Type v
Z : Type w
Z' : Type x
ι : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : f₀.Homotopy f₁
⊢ ∀ (x : X), { toFun := fun x => F (σ x.1, x.2), continuous_toFun := ⋯ }.toFun (1, x) = f₀ x
state_after: no goals
tactic: norm_num
Theorem: Finset.image₂_def
File: Mathlib/Data/Finset/Functor.lean

Proof steps:
state_before: α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
⊢ image₂ f s t = Seq.seq (f <$> s) fun x => t
state_after: case a
α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
a✝ : γ
⊢ a✝ ∈ image₂ f s t ↔ a✝ ∈ Seq.seq (f <$> s) fun x => t
tactic: ext
state_before: case a
α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
a✝ : γ
⊢ a✝ ∈ image₂ f s t ↔ a✝ ∈ Seq.seq (f <$> s) fun x => t
state_after: no goals
tactic: simp [mem_sup]
Theorem: Real.nnnorm_mul_toNNReal
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hy : 0 ≤ y
⊢ ‖x‖₊ * y.toNNReal = ‖x * y‖₊
state_after: no goals
tactic: rw [mul_comm, mul_comm x, toNNReal_mul_nnnorm x hy]
Theorem: Finset.card_eq_two
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ s.card = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}
state_after: case mp
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ s.card = 2 → ∃ x y, x ≠ y ∧ s = {x, y}

case mpr
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ x y, x ≠ y ∧ s = {x, y}) → s.card = 2
tactic: constructor
Theorem: irrational_nat_mul_iff
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑n * x) ↔ n ≠ 0 ∧ Irrational x
state_after: no goals
tactic: rw [← cast_natCast, irrational_rat_mul_iff, Nat.cast_ne_zero]
Theorem: Codisjoint.himp_inf_cancel_right
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ a ⇨ a ⊓ b = b
state_after: no goals
tactic: rw [himp_inf_distrib, himp_self, top_inf_eq, h.himp_eq_left]
Theorem: CategoryTheory.NatIso.inv_map_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G : C ⥤ D
X✝ Y✝ : C
F : C ⥤ D ⥤ E
X Y : C
e : X ≅ Y
Z : D
⊢ inv ((F.map e.inv).app Z) = (F.map e.hom).app Z
state_after: no goals
tactic: aesop_cat
Theorem: Finset.mem_sup
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Finset β
x : β
⊢ x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v
state_after: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Finset β
x : β
⊢ x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ (f v).val
tactic: change _ ↔ ∃ v ∈ s, x ∈ (f v).val
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Finset β
x : β
⊢ x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ (f v).val
state_after: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Finset β
x : β
⊢ x ∈ s.sup f ↔ x ∈ s.sup fun x => (f x).val.toFinset
tactic: rw [← Multiset.mem_sup, ← Multiset.mem_toFinset, sup_toFinset]
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
α : Type u_7
β : Type u_8
inst✝ : DecidableEq β
s : Finset α
f : α → Finset β
x : β
⊢ x ∈ s.sup f ↔ x ∈ s.sup fun x => (f x).val.toFinset
state_after: no goals
tactic: simp_rw [val_toFinset]
Theorem: List.pairwise_lt_range
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ Pairwise (fun x x_1 => x < x_1) (range n)
state_after: no goals
tactic: simp (config := {decide := true}) only [range_eq_range', pairwise_lt_range']
Theorem: MeasureTheory.le_measure_diff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ μ (s₁ ∩ s₂) + μ (s₁ \ s₂) ≤ μ s₂ + μ (s₁ \ s₂)
state_after: case bc.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s₁ ∩ s₂ ⊆ s₂
tactic: gcongr
state_before: case bc.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s₁ ∩ s₂ ⊆ s₂
state_after: no goals
tactic: apply inter_subset_right
Theorem: Polynomial.smeval_neg
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Ring R
S : Type u_2
inst✝² : AddCommGroup S
inst✝¹ : Pow S ℕ
inst✝ : Module R S
p q : R[X]
x : S
⊢ (-p).smeval x = -p.smeval x
state_after: no goals
tactic: rw [← add_eq_zero_iff_eq_neg, ← smeval_add, add_left_neg, smeval_zero]
Theorem: one_zpow
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✝ : DivisionMonoid α
a b c d : α
n : ℕ
⊢ 1 ^ ↑n = 1
state_after: no goals
tactic: rw [zpow_natCast, one_pow]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
n : ℕ
⊢ 1 ^ Int.negSucc n = 1
state_after: no goals
tactic: rw [zpow_negSucc, one_pow, inv_one]
Theorem: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
⊢ (binaryProductIso F G).inv ≫ Limits.prod.fst = prod.fst
state_after: no goals
tactic: simp [binaryProductIso, binaryProductLimitCone]
Theorem: antivaryOn_inv
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ AntivaryOn f⁻¹ g⁻¹ s ↔ AntivaryOn f g s
state_after: no goals
tactic: simp
Theorem: SatisfiesM.map
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
⊢ SatisfiesM q (f <$> x)
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ SatisfiesM q (f <$> x)
tactic: let ⟨x', hx⟩ := hx
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ SatisfiesM q (f <$> x)
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> x
tactic: refine ⟨(fun ⟨a, h⟩ => ⟨f a, hf h⟩) <$> x', ?_⟩
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> x
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> Subtype.val <$> x'
tactic: rw [← hx]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> Subtype.val <$> x'
state_after: no goals
tactic: simp [← comp_map, Function.comp_def]
Theorem: not_bddAbove_univ
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : NoMaxOrder α
⊢ ¬BddAbove univ
state_after: no goals
tactic: simp [BddAbove]
Theorem: eq_of_mul_inv_eq_one
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✝ : DivisionMonoid α
a b c d : α
h : a * b⁻¹ = 1
⊢ a = b
state_after: no goals
tactic: simpa using eq_inv_of_mul_eq_one_left h
Theorem: pow_boole
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✝¹ : Monoid M
a✝ b c : M
m n : ℕ
P : Prop
inst✝ : Decidable P
a : M
⊢ (a ^ if P then 1 else 0) = if P then a else 1
state_after: no goals
tactic: simp only [pow_ite, pow_one, pow_zero]
Theorem: PMF.support_uniformOfFinset
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nonempty
a : α
⊢ ∀ (x : α), x ∈ (uniformOfFinset s hs).support ↔ x ∈ ↑s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nonempty
a✝ a : α
ha : a ∈ s
⊢ ∀ (x : α), x ∈ (uniformOfFinset s ⋯).support ↔ x ∈ ↑s
tactic: let ⟨a, ha⟩ := hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nonempty
a✝ a : α
ha : a ∈ s
⊢ ∀ (x : α), x ∈ (uniformOfFinset s ⋯).support ↔ x ∈ ↑s
state_after: no goals
tactic: simp [mem_support_iff, Finset.ne_empty_of_mem ha]
Theorem: tprod_singleton
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
b : β
f : β → α
⊢ ∏' (x : ↑{b}), f ↑x = f b
state_after: no goals
tactic: rw [← coe_singleton, Finset.tprod_subtype', prod_singleton]
Theorem: CategoryTheory.IsPushout.of_top'
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C
h₁₁ : X₁₁ ⟶ X₁₂
h₂₁ : X₂₁ ⟶ X₂₂
h₃₁ : X₃₁ ⟶ X₃₂
v₁₁ : X₁₁ ⟶ X₂₁
v₁₂ : X₁₂ ⟶ X₂₂
v₁₃ : X₁₂ ⟶ X₃₂
v₂₁ : X₂₁ ⟶ X₃₁
s : IsPushout h₁₁ (v₁₁ ≫ v₂₁) v₁₃ h₃₁
t : IsPushout h₁₁ v₁₁ v₁₂ h₂₁
⊢ h₁₁ ≫ v₁₃ = v₁₁ ≫ v₂₁ ≫ h₃₁
state_after: no goals
tactic: rw [s.w, Category.assoc]
Theorem: Finset.nsmul_univ
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : Monoid α
s t : Finset α
a : α
m n : ℕ
inst✝ : Fintype α
hn : n ≠ 0
⊢ ↑(univ ^ n) = ↑univ
state_after: no goals
tactic: rw [coe_pow, coe_univ, Set.univ_pow hn]