ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsCyclotomicExtension.neZero
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
h : IsCyclotomicExtension {n} A B
inst✝ : IsDomain B
⊢ NeZero ↑↑n
state_after: case intro.intro
n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
h : IsCyclotomicExtension {n} A B
inst✝ : IsDomain B
r : B
hr : IsPrimitiveRoot r ↑n
⊢ NeZero ↑↑n
tactic: obtain ⟨⟨r, hr⟩, -⟩ := (iff_singleton n A B).1 h
state_before: case intro.intro
n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
h : IsCyclotomicExtension {n} A B
inst✝ : IsDomain B
r : B
hr : IsPrimitiveRoot r ↑n
⊢ NeZero ↑↑n
state_after: no goals
tactic: exact hr.neZero'
Theorem: Ideal.annihilator_quotient
File: Mathlib/RingTheory/Ideal/Colon.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N N₁ N₂ P P₁ P₂ : Submodule R M
I : Ideal R
⊢ Module.annihilator R (R ⧸ I) = I
state_after: no goals
tactic: rw [Submodule.annihilator_quotient, colon_top]
Theorem: sq_le_one_iff_abs_le_one
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a✝ b c a : α
⊢ a ^ 2 ≤ 1 ↔ |a| ≤ 1
state_after: no goals
tactic: simpa only [one_pow, abs_one] using @sq_le_sq _ _ a 1
Theorem: AddCommMonoidWithOne.toAddMonoidWithOne_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toAddMonoidWithOne R)
state_after: case mk.mk
R : Type u
toAddMonoidWithOne✝¹ : AddMonoidWithOne R
add_comm✝¹ : ∀ (a b : R), a + b = b + a
toAddMonoidWithOne✝ : AddMonoidWithOne R
add_comm✝ : ∀ (a b : R), a + b = b + a
a✝ : toAddMonoidWithOne = toAddMonoidWithOne
⊢ mk add_comm✝¹ = mk add_comm✝
tactic: rintro ⟨⟩ ⟨⟩ _
state_before: case mk.mk
R : Type u
toAddMonoidWithOne✝¹ : AddMonoidWithOne R
add_comm✝¹ : ∀ (a b : R), a + b = b + a
toAddMonoidWithOne✝ : AddMonoidWithOne R
add_comm✝ : ∀ (a b : R), a + b = b + a
a✝ : toAddMonoidWithOne = toAddMonoidWithOne
⊢ mk add_comm✝¹ = mk add_comm✝
state_after: no goals
tactic: congr
Theorem: Polynomial.natDegree_X_pow_add_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
r : R
⊢ (X ^ n + C r).natDegree = n
state_after: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
r : R
hn : n = 0
⊢ (X ^ n + C r).natDegree = n

case neg
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Nontrivial R
inst✝ : Semiring R
n : ℕ
r : R
hn : ¬n = 0
⊢ (X ^ n + C r).natDegree = n
tactic: by_cases hn : n = 0
Theorem: RelIso.preimage_eq_image_symm
File: Mathlib/Order/RelIso/Set.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
u : δ → δ → Prop
α : Type u_5
β : Type u_6
r : α → α → Prop
s : β → β → Prop
e : r ≃r s
t : Set β
⊢ ⇑e ⁻¹' t = ⇑e.symm '' t
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
u : δ → δ → Prop
α : Type u_5
β : Type u_6
r : α → α → Prop
s : β → β → Prop
e : r ≃r s
t : Set β
⊢ ⇑e ⁻¹' t = ⇑e.symm.symm ⁻¹' t
tactic: rw [e.symm.image_eq_preimage_symm]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
u : δ → δ → Prop
α : Type u_5
β : Type u_6
r : α → α → Prop
s : β → β → Prop
e : r ≃r s
t : Set β
⊢ ⇑e ⁻¹' t = ⇑e.symm.symm ⁻¹' t
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.AEEqFun.coeFn_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ ↑(mk f hf) =ᶠ[ae μ] f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ ↑(Quotient.out' (mk f hf)) =ᶠ[ae μ] f
tactic: apply (AEStronglyMeasurable.ae_eq_mk _).symm.trans
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : AEStronglyMeasurable f μ
⊢ ↑(Quotient.out' (mk f hf)) =ᶠ[ae μ] f
state_after: no goals
tactic: exact @Quotient.mk_out' _ (μ.aeEqSetoid β) (⟨f, hf⟩ : { f // AEStronglyMeasurable f μ })
Theorem: Real.mk_add
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
f g : CauSeq ℚ abs
⊢ mk (f + g) = mk f + mk g
state_after: no goals
tactic: simp [mk, ← ofCauchy_add]
Theorem: CategoryTheory.isSeparator_op_iff
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
⊢ IsSeparator (op G) ↔ IsCoseparator G
state_after: no goals
tactic: rw [IsSeparator, IsCoseparator, ← isSeparating_op_iff, Set.singleton_op]
Theorem: Complex.ofReal_tan_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (tan ↑x) = tan ↑x
state_after: no goals
tactic: rw [← tan_conj, conj_ofReal]
Theorem: CategoryTheory.ShortComplex.opcyclesIsoCokernel_inv
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.213956, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝¹ : S.HasRightHomology
inst✝ : HasCokernel S.f
⊢ S.f ≫ cokernel.π S.f = 0
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝³ : Category.{?u.213956, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝¹ : S.HasRightHomology
inst✝ : HasCokernel S.f
⊢ S.f ≫ S.pOpcycles = 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.IsPullback.inl_snd'
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPullback b.inl 0 b.snd 0
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPullback (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
tactic: refine of_right ?_ (by simp) (of_isBilimit h)
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPullback (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
state_after: no goals
tactic: simp
Theorem: Asymptotics.superpolynomialDecay_param_mul_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
h : SuperpolynomialDecay l k (k * f)
x : α
hx : k x ≠ 0
⊢ (k⁻¹ * (k * f)) x = f x
state_after: no goals
tactic: simp [← mul_assoc, inv_mul_cancel hx]
Theorem: Multiset.count_map_eq_count
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Set.InjOn f {x | x ∈ s}
x : α
H : x ∈ s
⊢ count (f x) (map f s) = count x s
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝¹ : DecidableEq α
s✝ : Multiset α
inst✝ : DecidableEq β
f : α → β
s : Multiset α
hf : Set.InjOn f {x | x ∈ s}
x : α
H : x ∈ s
⊢ count x (filter (fun a => f x = f a) s) = card (filter (fun a => f x = f a) s)
tactic: suffices (filter (fun a : α => f x = f a) s).count x = card (filter (fun a : α => f x = f a) s) by
    rw [count, countP_map, ← this]
    exact count_filter_of_pos <| rfl
Theorem: Filter.Tendsto.eventually_forall_le_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
l : Filter α
p : β → Prop
f : α → β
hf : Tendsto f l atBot
h_evtl : ∀ᶠ (x : β) in atBot, p x
⊢ ∀ᶠ (x : α) in l, ∀ y ≤ f x, p y
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
l : Filter α
p : β → Prop
f : α → β
hf : Tendsto f l atBot
h_evtl : ∀ᶠ (x : β) in atBot, ∀ y ≤ x, p y
⊢ ∀ᶠ (x : α) in l, ∀ y ≤ f x, p y
tactic: rw [← Filter.eventually_forall_le_atBot] at h_evtl
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
l : Filter α
p : β → Prop
f : α → β
hf : Tendsto f l atBot
h_evtl : ∀ᶠ (x : β) in atBot, ∀ y ≤ x, p y
⊢ ∀ᶠ (x : α) in l, ∀ y ≤ f x, p y
state_after: no goals
tactic: exact (h_evtl.comap f).filter_mono hf.le_comap
Theorem: List.Subperm.sym2
File: Mathlib/Data/List/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
xs ys : List α
h : xs <+~ ys
⊢ xs.sym2 <+~ ys.sym2
state_after: case intro.intro
α : Type u_1
β : Type u_2
xs ys xs' : List α
hx : xs' ~ xs
h : xs' <+ ys
⊢ xs.sym2 <+~ ys.sym2
tactic: obtain ⟨xs', hx, h⟩ := h
state_before: case intro.intro
α : Type u_1
β : Type u_2
xs ys xs' : List α
hx : xs' ~ xs
h : xs' <+ ys
⊢ xs.sym2 <+~ ys.sym2
state_after: no goals
tactic: exact hx.sym2.symm.subperm.trans h.sym2.subperm
Theorem: CategoryTheory.ShiftMkCore.shiftFunctor_eq
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a : A
⊢ shiftFunctor C a = h.F a
state_after: no goals
tactic: rfl
Theorem: exterior_subset_exterior
File: Mathlib/Topology/AlexandrovDiscrete.lean

Proof steps:
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t ↔ 𝓝ˢ s ≤ 𝓝ˢ t
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → 𝓝ˢ s ≤ 𝓝ˢ t
tactic: refine ⟨?_, fun h ↦ ker_mono h⟩
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → 𝓝ˢ s ≤ 𝓝ˢ t
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → ∀ (x : Set α), exterior t ⊆ x → exterior s ⊆ x
tactic: simp_rw [le_def, ← exterior_subset_iff_mem_nhdsSet]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
⊢ exterior s ⊆ exterior t → ∀ (x : Set α), exterior t ⊆ x → exterior s ⊆ x
state_after: no goals
tactic: exact fun h u ↦ h.trans
Theorem: gaugeSeminorm_ball_one
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝⁴ : RCLike 𝕜
inst✝³ : Module 𝕜 E
inst✝² : IsScalarTower ℝ 𝕜 E
hs₀ : Balanced 𝕜 s
hs₁ : Convex ℝ s
hs₂ : Absorbent ℝ s
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : IsOpen s
⊢ (gaugeSeminorm hs₀ hs₁ hs₂).ball 0 1 = s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝⁴ : RCLike 𝕜
inst✝³ : Module 𝕜 E
inst✝² : IsScalarTower ℝ 𝕜 E
hs₀ : Balanced 𝕜 s
hs₁ : Convex ℝ s
hs₂ : Absorbent ℝ s
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : IsOpen s
⊢ {y | (gaugeSeminorm hs₀ hs₁ hs₂) y < 1} = s
tactic: rw [Seminorm.ball_zero_eq]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝⁴ : RCLike 𝕜
inst✝³ : Module 𝕜 E
inst✝² : IsScalarTower ℝ 𝕜 E
hs₀ : Balanced 𝕜 s
hs₁ : Convex ℝ s
hs₂ : Absorbent ℝ s
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs : IsOpen s
⊢ {y | (gaugeSeminorm hs₀ hs₁ hs₂) y < 1} = s
state_after: no goals
tactic: exact gauge_lt_one_eq_self_of_isOpen hs₁ hs₂.zero_mem hs
Theorem: SemiconjBy.conj_mk
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y a x : G
⊢ SemiconjBy a x (a * x * a⁻¹)
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y a x : G
⊢ a * x = a * x * a⁻¹ * a
tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y a x : G
⊢ a * x = a * x * a⁻¹ * a
state_after: no goals
tactic: rw [mul_assoc, inv_mul_self, mul_one]
Theorem: SimpleGraph.isAcyclic_iff_forall_adj_isBridge
File: Mathlib/Combinatorics/SimpleGraph/Acyclic.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
⊢ G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.IsBridge s(v, w)
state_after: V : Type u
G : SimpleGraph V
⊢ G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges
tactic: simp_rw [isBridge_iff_adj_and_forall_cycle_not_mem]
state_before: V : Type u
G : SimpleGraph V
⊢ G.IsAcyclic ↔ ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges
state_after: case mp
V : Type u
G : SimpleGraph V
⊢ G.IsAcyclic → ∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges

case mpr
V : Type u
G : SimpleGraph V
⊢ (∀ ⦃v w : V⦄, G.Adj v w → G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges) → G.IsAcyclic
tactic: constructor
Theorem: exists_covby_infinite_Ici_of_infinite_Ici
File: Mathlib/Order/Atoms/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
⊢ ∃ b, a ⋖ b ∧ (Set.Ici b).Infinite
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
⊢ False
tactic: by_contra! h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
b : α
hb : b ∈ Set.Ici a \ {a}
⊢ b ∈ ⋃ i ∈ {x | a ⋖ x}, Set.Ici i
tactic: refine ((hfin.biUnion (t := Set.Ici) (by simpa using h)).subset (fun b hb ↦ ?_)).not_infinite
    (ha.diff (Set.finite_singleton a))
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
b : α
hb : b ∈ Set.Ici a \ {a}
⊢ b ∈ ⋃ i ∈ {x | a ⋖ x}, Set.Ici i
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
b : α
hb : b ∈ Set.Ici a \ {a}
x : α
hax : a ⋖ x
hxb : x ≤ b
⊢ b ∈ ⋃ i ∈ {x | a ⋖ x}, Set.Ici i
tactic: obtain ⟨x, hax, hxb⟩ := ((show a ≤ b from hb.1).lt_of_ne (Ne.symm hb.2)).exists_covby_le
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
a : α
inst✝ : IsStronglyAtomic α
ha : (Set.Ici a).Infinite
hfin : {x | a ⋖ x}.Finite
h : ∀ (b : α), a ⋖ b → ¬(Set.Ici b).Infinite
b : α
hb : b ∈ Set.Ici a \ {a}
x : α
hax : a ⋖ x
hxb : x ≤ b
⊢ b ∈ ⋃ i ∈ {x | a ⋖ x}, Set.Ici i
state_after: no goals
tactic: exact Set.mem_biUnion hax hxb
Theorem: Multiset.map_add_left_Ico
File: Mathlib/Algebra/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ico a b) = Ico (c + a) (c + b)
state_after: no goals
tactic: classical rw [Ico, Ico, ← Finset.image_add_left_Ico, Finset.image_val,
      ((Finset.nodup _).map <| add_right_injective c).dedup]
Theorem: UniformInducing.equicontinuousAt_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
u : α → β
hu : UniformInducing u
⊢ EquicontinuousAt F x₀ ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x₀
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
u : α → β
hu : UniformInducing u
this : Inducing (⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun)
⊢ EquicontinuousAt F x₀ ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x₀
tactic: have := (UniformFun.postcomp_uniformInducing (α := ι) hu).inducing
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
u : α → β
hu : UniformInducing u
this : Inducing (⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun)
⊢ EquicontinuousAt F x₀ ↔ EquicontinuousAt ((fun x => u ∘ x) ∘ F) x₀
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
u : α → β
hu : UniformInducing u
this : Inducing (⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun)
⊢ ContinuousAt ((⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun) ∘ ⇑UniformFun.ofFun ∘ swap F) x₀ ↔
    ContinuousAt (⇑UniformFun.ofFun ∘ swap ((fun x => u ∘ x) ∘ F)) x₀
tactic: rw [equicontinuousAt_iff_continuousAt, equicontinuousAt_iff_continuousAt, this.continuousAt_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
u : α → β
hu : UniformInducing u
this : Inducing (⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun)
⊢ ContinuousAt ((⇑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ⇑toFun) ∘ ⇑UniformFun.ofFun ∘ swap F) x₀ ↔
    ContinuousAt (⇑UniformFun.ofFun ∘ swap ((fun x => u ∘ x) ∘ F)) x₀
state_after: no goals
tactic: rfl
Theorem: Rat.mul_zero
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : Rat
⊢ a * 0 = 0
state_after: no goals
tactic: simp [mul_def]
Theorem: Real.tan_lt_tan_of_nonneg_of_lt_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y < π / 2
hxy : x < y
⊢ -(π / 2) < x
state_after: no goals
tactic: linarith
Theorem: Module.Finite_of_isLocalization
File: Mathlib/RingTheory/LocalProperties.lean

Proof steps:
state_before: R✝ S✝ : Type u
inst✝¹⁸ : CommRing R✝
inst✝¹⁷ : CommRing S✝
M✝ : Submonoid R✝
N : Submonoid S✝
R' S' : Type u
inst✝¹⁶ : CommRing R'
inst✝¹⁵ : CommRing S'
f : R✝ →+* S✝
inst✝¹⁴ : Algebra R✝ R'
inst✝¹³ : Algebra S✝ S'
R : Type u_1
S : Type u_2
Rₚ : Type u_3
Sₚ : Type u_4
inst✝¹² : CommSemiring R
inst✝¹¹ : CommRing S
inst✝¹⁰ : CommRing Rₚ
inst✝⁹ : CommRing Sₚ
inst✝⁸ : Algebra R S
inst✝⁷ : Algebra R Rₚ
inst✝⁶ : Algebra R Sₚ
inst✝⁵ : Algebra S Sₚ
inst✝⁴ : Algebra Rₚ Sₚ
inst✝³ : IsScalarTower R S Sₚ
inst✝² : IsScalarTower R Rₚ Sₚ
M : Submonoid R
inst✝¹ : IsLocalization M Rₚ
inst✝ : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₚ
hRS : Finite R S
⊢ Finite Rₚ Sₚ
state_after: no goals
tactic: classical
  have : algebraMap Rₚ Sₚ = IsLocalization.map (T := Algebra.algebraMapSubmonoid S M) Sₚ
      (algebraMap R S) (Submonoid.le_comap_map M) := by
    apply IsLocalization.ringHom_ext M
    simp only [IsLocalization.map_comp, ← IsScalarTower.algebraMap_eq]
  -- We claim that if `S` is generated by `T` as an `R`-module,
  -- then `S'` is generated by `T` as an `R'`-module.
  obtain ⟨T, hT⟩ := hRS
  use T.image (algebraMap S Sₚ)
  rw [eq_top_iff]
  rintro x -
  -- By the hypotheses, for each `x : S'`, we have `x = y / (f r)` for some `y : S` and `r : M`.
  -- Since `S` is generated by `T`, the image of `y` should fall in the span of the image of `T`.
  obtain ⟨y, ⟨_, ⟨r, hr, rfl⟩⟩, rfl⟩ :=
    IsLocalization.mk'_surjective (Algebra.algebraMapSubmonoid S M) x
  rw [IsLocalization.mk'_eq_mul_mk'_one, mul_comm, Finset.coe_image]
  have hy : y ∈ Submodule.span R ↑T := by rw [hT]; trivial
  replace hy : algebraMap S Sₚ y ∈ Submodule.map (IsScalarTower.toAlgHom R S Sₚ).toLinearMap
    (Submodule.span R (T : Set S)) := Submodule.mem_map_of_mem
--     -- Note: #8386 had to specify the value of `f` below
      (f := (IsScalarTower.toAlgHom R S Sₚ).toLinearMap) hy
  rw [Submodule.map_span (IsScalarTower.toAlgHom R S Sₚ).toLinearMap T] at hy
  have H : Submodule.span R (algebraMap S Sₚ '' T) ≤
      (Submodule.span Rₚ (algebraMap S Sₚ '' T)).restrictScalars R := by
    rw [Submodule.span_le]; exact Submodule.subset_span
  -- Now, since `y ∈ span T`, and `(f r)⁻¹ ∈ R'`, `x / (f r)` is in `span T` as well.
  convert (Submodule.span Rₚ (algebraMap S Sₚ '' T)).smul_mem
    (IsLocalization.mk' Rₚ (1 : R) ⟨r, hr⟩) (H hy) using 1
  rw [Algebra.smul_def, this, IsLocalization.map_mk', map_one]
Theorem: MeasurableSpace.measurableSet_bot_iff
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u s : Set α
⊢ ∀ (s : Set α), (fun s => s = ∅ ∨ s = univ) s → (fun s => s = ∅ ∨ s = univ) sᶜ
state_after: no goals
tactic: simp (config := { contextual := true }) [or_imp]
Theorem: UpperSet.codisjoint_coe
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
⊢ Codisjoint ↑s ↑t ↔ Disjoint s t
state_after: no goals
tactic: simp [disjoint_iff, codisjoint_iff, SetLike.ext'_iff]