ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HahnSeries.sub_coeff'
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
⊢ (x - y).coeff = x.coeff - y.coeff
state_after: case h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
x✝ : Γ
⊢ (x - y).coeff x✝ = (x.coeff - y.coeff) x✝
tactic: ext
state_before: case h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x y : HahnSeries Γ R
x✝ : Γ
⊢ (x - y).coeff x✝ = (x.coeff - y.coeff) x✝
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: MeasureTheory.IsStoppingTime.measurableSet_inter_eq_iff
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
⊢ MeasurableSet (s ∩ {ω | τ ω = i}) ↔ MeasurableSet (s ∩ {ω | τ ω = i})
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
this : ∀ (j : ι), {ω | τ ω = i} ∩ {ω | τ ω ≤ j} = {ω | τ ω = i} ∩ {_ω | i ≤ j}
⊢ MeasurableSet (s ∩ {ω | τ ω = i}) ↔ MeasurableSet (s ∩ {ω | τ ω = i})
tactic: have : ∀ j, {ω : Ω | τ ω = i} ∩ {ω : Ω | τ ω ≤ j} = {ω : Ω | τ ω = i} ∩ {_ω | i ≤ j} := by
    intro j
    ext1 ω
    simp only [Set.mem_inter_iff, Set.mem_setOf_eq, and_congr_right_iff]
    intro hxi
    rw [hxi]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
this : ∀ (j : ι), {ω | τ ω = i} ∩ {ω | τ ω ≤ j} = {ω | τ ω = i} ∩ {_ω | i ≤ j}
⊢ MeasurableSet (s ∩ {ω | τ ω = i}) ↔ MeasurableSet (s ∩ {ω | τ ω = i})
state_after: case mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
this : ∀ (j : ι), {ω | τ ω = i} ∩ {ω | τ ω ≤ j} = {ω | τ ω = i} ∩ {_ω | i ≤ j}
h : MeasurableSet (s ∩ {ω | τ ω = i})
⊢ MeasurableSet (s ∩ {ω | τ ω = i})

case mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
s : Set Ω
i : ι
this : ∀ (j : ι), {ω | τ ω = i} ∩ {ω | τ ω ≤ j} = {ω | τ ω = i} ∩ {_ω | i ≤ j}
h : MeasurableSet (s ∩ {ω | τ ω = i})
⊢ MeasurableSet (s ∩ {ω | τ ω = i})
tactic: constructor <;> intro h
Theorem: Cardinal.one_lt_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
⊢ 1 < ↑m ↔ 1 < m
state_after: no goals
tactic: norm_cast
Theorem: Finmap.lookup_insert
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s✝ : Finmap β
s : AList β
⊢ lookup a (insert a b ⟦s⟧) = some b
state_after: no goals
tactic: simp only [insert_toFinmap, lookup_toFinmap, AList.lookup_insert]
Theorem: Dioph.diophFn_comp
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β : Type
n : ℕ
f : Vector3 ℕ n → ℕ
df : DiophFn f
g : Vector3 ((α → ℕ) → ℕ) n
dg : VectorAllP DiophFn g
⊢ VectorAllP DiophFn ((fun v => v none) :: fun i v => g i (v ∘ some))
state_after: α β : Type
n : ℕ
f : Vector3 ℕ n → ℕ
df : DiophFn f
g : Vector3 ((α → ℕ) → ℕ) n
dg : VectorAllP DiophFn g
⊢ (DiophFn fun v => v none) ∧ VectorAllP DiophFn fun i v => g i (v ∘ some)
tactic: simp only [vectorAllP_cons]
state_before: α β : Type
n : ℕ
f : Vector3 ℕ n → ℕ
df : DiophFn f
g : Vector3 ((α → ℕ) → ℕ) n
dg : VectorAllP DiophFn g
⊢ (DiophFn fun v => v none) ∧ VectorAllP DiophFn fun i v => g i (v ∘ some)
state_after: no goals
tactic: exact ⟨proj_dioph none, (vectorAllP_iff_forall _ _).2 fun i =>
          reindex_diophFn _ <| (vectorAllP_iff_forall _ _).1 dg _⟩
Theorem: singleton_sub_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / closedBall y δ = closedBall (x / y) δ
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, inv_closedBall, singleton_mul_closedBall]
Theorem: List.sizeOf_lt_sizeOf_of_mem
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
l : List α
hx : x ∈ l
⊢ sizeOf x < sizeOf l
state_after: case cons.head
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : SizeOf α
x : α
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
⊢ sizeOf x < 1 + sizeOf x + sizeOf t

case cons.tail
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : SizeOf α
x h : α
t : List α
ih : x ∈ t → sizeOf x < sizeOf t
a✝ : Mem x t
⊢ sizeOf x < 1 + sizeOf h + sizeOf t
tactic: induction' l with h t ih <;> cases hx <;> rw [cons.sizeOf_spec]
Theorem: Equiv.Perm.support_swap_mul_swap
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : [x, y, z].Nodup
⊢ (swap x y * swap y z).support = {x, y, z}
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : ¬(x = y ∨ x = z ∨ False) ∧ ¬(y = z ∨ False)
⊢ (swap x y * swap y z).support = {x, y, z}
tactic: simp only [List.not_mem_nil, and_true_iff, List.mem_cons, not_false_iff, List.nodup_cons,
    List.mem_singleton, and_self_iff, List.nodup_nil] at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : ¬(x = y ∨ x = z ∨ False) ∧ ¬(y = z ∨ False)
⊢ (swap x y * swap y z).support = {x, y, z}
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : (x ≠ y ∧ x ≠ z ∧ ¬False) ∧ y ≠ z ∧ ¬False
⊢ (swap x y * swap y z).support = {x, y, z}
tactic: push_neg at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : (x ≠ y ∧ x ≠ z ∧ ¬False) ∧ y ≠ z ∧ ¬False
⊢ (swap x y * swap y z).support = {x, y, z}
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : (x ≠ y ∧ x ≠ z ∧ ¬False) ∧ y ≠ z ∧ ¬False
⊢ (swap x y * swap y z).support ≤ {x, y, z}

case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y z : α
h : (x ≠ y ∧ x ≠ z ∧ ¬False) ∧ y ≠ z ∧ ¬False
⊢ {x, y, z} ≤ (swap x y * swap y z).support
tactic: apply le_antisymm
Theorem: AddCommGrp.hasLimit_iff_small_sections
File: Mathlib/Algebra/Category/Grp/Limits.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections
state_after: case mp
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ HasLimit F → Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections

case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections → HasLimit F
tactic: constructor
Theorem: EllipticCurve.ofJ1728_j
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
inst✝ : Invertible 2
⊢ (ofJ1728 R).j = 1728
state_after: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
inst✝ : Invertible 2
⊢ -(1728 * 2 ^ 6) = (-48) ^ 3
tactic: field_simp [j, ofJ1728, @val_unitOfInvertible _ _ _ <| invertibleNeg _,
    WeierstrassCurve.ofJ1728_c₄]
state_before: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
inst✝ : Invertible 2
⊢ -(1728 * 2 ^ 6) = (-48) ^ 3
state_after: no goals
tactic: norm_num1
Theorem: FintypeCat.toLightProfinite_map_apply
File: Mathlib/Topology/Category/LightProfinite/Basic.lean

Proof steps:
state_before: X✝ Y✝ : FintypeCat
f : X✝ ⟶ Y✝
⊢ Continuous f
state_after: no goals
tactic: continuity
Theorem: Monotone.tendsto_leftLim
File: Mathlib/Topology/Order/LeftRightLim.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
⊢ Tendsto f (𝓝[<] x) (𝓝 (leftLim f x))
state_after: case inl
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[<] x = ⊥
⊢ Tendsto f (𝓝[<] x) (𝓝 (leftLim f x))

case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[<] x ≠ ⊥
⊢ Tendsto f (𝓝[<] x) (𝓝 (leftLim f x))
tactic: rcases eq_or_ne (𝓝[<] x) ⊥ with (h' | h')
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[<] x ≠ ⊥
⊢ Tendsto f (𝓝[<] x) (𝓝 (leftLim f x))
state_after: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[<] x ≠ ⊥
⊢ Tendsto f (𝓝[<] x) (𝓝 (sSup (f '' Iio x)))
tactic: rw [leftLim_eq_sSup hf h']
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x✝ y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
x : α
h' : 𝓝[<] x ≠ ⊥
⊢ Tendsto f (𝓝[<] x) (𝓝 (sSup (f '' Iio x)))
state_after: no goals
tactic: exact hf.tendsto_nhdsWithin_Iio x
Theorem: Filter.blimsup_mono
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
h : ∀ (x : β), p x → q x
a : α
ha : a ∈ {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}
⊢ ∀ (x : β), (q x → u x ≤ a) → p x → u x ≤ a
state_after: no goals
tactic: tauto
Theorem: SetTheory.PGame.birthday_nat_add
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: a b x : PGame
n : ℕ
⊢ (↑n + a).birthday = a.birthday + ↑n
state_after: no goals
tactic: simp
Theorem: PMF.mem_support_normalize_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0∞
hf0 : tsum f ≠ 0
hf : tsum f ≠ ⊤
a : α
⊢ a ∈ (normalize f hf0 hf).support ↔ f a ≠ 0
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.ex
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ T.SemanticallyEquivalent (∃'φ) (∃'ψ)
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∃ a, φ.Realize v (Fin.snoc xs a)) ↔ ∃ a, ψ.Realize v (Fin.snoc xs a)
tactic: simp_rw [SemanticallyEquivalent, ModelsBoundedFormula, BoundedFormula.realize_iff,
    BoundedFormula.realize_ex]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∃ a, φ.Realize v (Fin.snoc xs a)) ↔ ∃ a, ψ.Realize v (Fin.snoc xs a)
state_after: no goals
tactic: exact fun M v xs => exists_congr fun a => h.realize_bd_iff
Theorem: Equiv.Perm.toCycle_eq_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
⊢ f.toCycle hf = ↑(f.toList x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ f.toCycle hf = ↑(f.toList x)
tactic: have key : (Finset.univ : Finset α).val = x ::ₘ Finset.univ.val.erase x := by simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ f.toCycle hf = ↑(f.toList x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ (x ::ₘ Finset.univ.val.erase x).recOn (Quot.mk Setoid.r []) (fun x x_1 l => if f x = x then l else ↑(f.toList x)) ⋯ =
    ↑(f.toList x)
tactic: rw [toCycle, key]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : f.IsCycle
x : α
hx : f x ≠ x
key : Finset.univ.val = x ::ₘ Finset.univ.val.erase x
⊢ (x ::ₘ Finset.univ.val.erase x).recOn (Quot.mk Setoid.r []) (fun x x_1 l => if f x = x then l else ↑(f.toList x)) ⋯ =
    ↑(f.toList x)
state_after: no goals
tactic: simp [hx]
Theorem: Real.rpow_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z✝ : ℝ
n : ℕ
x : ℝ
hx : 0 ≤ x
y z : ℝ
⊢ x ^ (y * z) = (x ^ y) ^ z
state_after: no goals
tactic: rw [← Complex.ofReal_inj, Complex.ofReal_cpow (rpow_nonneg hx _),
      Complex.ofReal_cpow hx, Complex.ofReal_mul, Complex.cpow_mul, Complex.ofReal_cpow hx] <;>
    simp only [(Complex.ofReal_mul _ _).symm, (Complex.ofReal_log hx).symm, Complex.ofReal_im,
      neg_lt_zero, pi_pos, le_of_lt pi_pos]
Theorem: TensorPower.gradedMonoid_eq_of_cast
File: Mathlib/LinearAlgebra/TensorPower.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : (cast R M h) a.snd = b.snd
⊢ a = b
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : (cast R M h) a.snd = b.snd
⊢ (reindex R (fun x => M) (Equiv.cast ⋯)) a.snd = b.snd
tactic: refine gradedMonoid_eq_of_reindex_cast h ?_
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : (cast R M h) a.snd = b.snd
⊢ (reindex R (fun x => M) (Equiv.cast ⋯)) a.snd = b.snd
state_after: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : (reindex R (fun x => M) (finCongr h)) a.snd = b.snd
⊢ (reindex R (fun x => M) (Equiv.cast ⋯)) a.snd = b.snd
tactic: rw [cast] at h2
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : (reindex R (fun x => M) (finCongr h)) a.snd = b.snd
⊢ (reindex R (fun x => M) (Equiv.cast ⋯)) a.snd = b.snd
state_after: no goals
tactic: rw [← finCongr_eq_equivCast, ← h2]
Theorem: DFinsupp.erase_ne
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i i' : ι
f : Π₀ (i : ι), β i
h : i' ≠ i
⊢ (erase i f) i' = f i'
state_after: no goals
tactic: simp [h]
Theorem: AddSubmonoid.mem_iSup
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ m ∈ ⨆ i, p i ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ (∀ (b : Submonoid M), (∀ (i : ι), p i ≤ b) → closure {m} ≤ b) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
tactic: rw [← closure_singleton_le_iff_mem, le_iSup_iff]
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_4
p : ι → Submonoid M
m : M
⊢ (∀ (b : Submonoid M), (∀ (i : ι), p i ≤ b) → closure {m} ≤ b) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
state_after: no goals
tactic: simp only [closure_singleton_le_iff_mem]
Theorem: HasSum.update'
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✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
⊢ a * x = a' * f b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => f b_1 * if b_1 = b then x else 1) (a * x)
⊢ a * x = a' * f b
tactic: have h := hf.mul (hasProd_ite_eq b x)
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => f b_1 * if b_1 = b then x else 1) (a * x)
⊢ a * x = a' * f b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => update f b x b_1 * if b_1 = b then f b else 1) (a * x)
⊢ a * x = a' * f b
tactic: simp_rw [this] at h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a a' : α
hf : HasProd f a
b : β
x : α
hf' : HasProd (update f b x) a'
this : ∀ (b' : β), (f b' * if b' = b then x else 1) = update f b x b' * if b' = b then f b else 1
h : HasProd (fun b_1 => update f b x b_1 * if b_1 = b then f b else 1) (a * x)
⊢ a * x = a' * f b
state_after: no goals
tactic: exact HasProd.unique h (hf'.mul (hasProd_ite_eq b (f b)))
Theorem: locallyLipschitz_inv_iff
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α✝ : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝³ : SeminormedCommGroup E✝
inst✝² : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E✝
r r₁ r₂ : ℝ
α : Type u_5
E : Type u_6
inst✝¹ : SeminormedCommGroup E
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f g : α → E
s : Set α
x : α
⊢ LocallyLipschitz f⁻¹ ↔ LocallyLipschitz f
state_after: no goals
tactic: simp [LocallyLipschitz]
Theorem: LinearAlgebra.FreeProduct.ι_apply
File: Mathlib/LinearAlgebra/FreeProduct/Basic.lean

Proof steps:
state_before: I : Type u
inst✝⁵ : DecidableEq I
i : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
x : ⨁ (i : I), A i
⊢ { toQuot := Quot.mk (RingQuot.Rel (rel R A)) ((ι R) x) } = (ι' R A) x
state_after: no goals
tactic: aesop (add simp [ι', mkAlgHom, RingQuot.mkAlgHom, mkRingHom])
Theorem: Finset.sum_smul_sum
File: Mathlib/Algebra/Module/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
R : Type u_5
M : Type u_6
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s✝ : R
x y : M
s : Finset α
t : Finset β
f : α → R
g : β → M
⊢ (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j
state_after: no goals
tactic: simp_rw [sum_smul, ← smul_sum]
Theorem: AddMonoid.IsTorsionFree.card_add_card_sub_nonneg_card_add
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
h : IsTorsionFree α
hs : s.Nonempty
ht : t.Nonempty
⊢ s.card + t.card - 1 ≤ (s * t).card
state_after: no goals
tactic: simpa only [h.minOrder, min_eq_right, le_top, Nat.cast_le] using Finset.min_le_card_mul hs ht
Theorem: SetTheory.PGame.grundyValue_eq_iff_equiv_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
⊢ G.grundyValue = o → G ≈ nim o
state_after: G : PGame
inst✝ : G.Impartial
⊢ G ≈ nim G.grundyValue
tactic: rintro rfl
state_before: G : PGame
inst✝ : G.Impartial
⊢ G ≈ nim G.grundyValue
state_after: no goals
tactic: exact equiv_nim_grundyValue G
state_before: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
⊢ G ≈ nim o → G.grundyValue = o
state_after: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
h : G ≈ nim o
⊢ G.grundyValue = o
tactic: intro h
state_before: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
h : G ≈ nim o
⊢ G.grundyValue = o
state_after: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
h : G ≈ nim o
⊢ nim G.grundyValue ≈ nim o
tactic: rw [← nim_equiv_iff_eq]
state_before: G : PGame
inst✝ : G.Impartial
o : Ordinal.{u_1}
h : G ≈ nim o
⊢ nim G.grundyValue ≈ nim o
state_after: no goals
tactic: exact Equiv.trans (Equiv.symm (equiv_nim_grundyValue G)) h
Theorem: OrderIso.funUnique_apply
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : Preorder α✝
inst✝³ : Preorder β✝
inst✝² : Preorder γ
α : Type u_6
β : Type u_7
inst✝¹ : Unique α
inst✝ : Preorder β
⊢ ∀ {a b : α → β}, (Equiv.funUnique α β) a ≤ (Equiv.funUnique α β) b ↔ a ≤ b
state_after: no goals
tactic: simp [Pi.le_def, Unique.forall_iff]
Theorem: frontier_prod_eq
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
⊢ frontier (s ×ˢ t) = closure s ×ˢ frontier t ∪ frontier s ×ˢ closure t
state_after: no goals
tactic: simp only [frontier, closure_prod_eq, interior_prod_eq, prod_diff_prod]
Theorem: exists_subtype_mk_eq_iff
File: Mathlib/Data/Subtype.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
p q : α → Prop
a : Subtype p
b : α
⊢ (∃ h, ⟨b, h⟩ = a) ↔ b = ↑a
state_after: no goals
tactic: simp only [@eq_comm _ b, exists_eq_subtype_mk_iff, @eq_comm _ _ a]