ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Relation.TransGen.lift'
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b✝ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → TransGen p (f a) (f b)
hab : TransGen r a b
⊢ TransGen p (f a) (f b)
state_after: no goals
tactic: simpa [transGen_idem] using hab.lift f h
Theorem: List.perm_append_singleton
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
a : α
l : List α
⊢ a :: (l ++ []) ~ a :: l
state_after: no goals
tactic: rw [append_nil]
Theorem: Set.Iic.coe_iSup
File: Mathlib/Order/CompleteLatticeIntervals.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ ↑(⨆ i, f i) = ⨆ i, ↑(f i)
state_after: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ sSup (Subtype.val '' range fun i => f i) = ⨆ i, ↑(f i)
tactic: rw [iSup, coe_sSup]
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ sSup (Subtype.val '' range fun i => f i) = ⨆ i, ↑(f i)
state_after: case e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)
tactic: congr
state_before: case e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)
state_after: case e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
tactic: ext
state_before: case e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
state_after: no goals
tactic: simp
Theorem: TopologicalSpace.Opens.coe_iSup
File: Mathlib/Topology/Sets/Opens.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Sort u_5
s : ι → Opens α
⊢ ↑(⨆ i, s i) = ⋃ i, ↑(s i)
state_after: no goals
tactic: simp [iSup]
Theorem: AddAction.pretransitive_iff_subsingleton_quotient
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
⊢ IsPretransitive G α ↔ Subsingleton (orbitRel.Quotient G α)
state_after: case refine_1
G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x✝ : IsPretransitive G α
a b : orbitRel.Quotient G α
⊢ a = b

case refine_2
G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x✝ : Subsingleton (orbitRel.Quotient G α)
a b : α
⊢ ∃ g, g • a = b
tactic: refine ⟨fun _ ↦ ⟨fun a b ↦ ?_⟩, fun _ ↦ ⟨fun a b ↦ ?_⟩⟩
Theorem: Hyperreal.IsSt.infinitesimal_sub
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
r : ℝ
hxr : x.IsSt r
⊢ (x - ↑r).Infinitesimal
state_after: no goals
tactic: simpa only [sub_self] using hxr.sub (isSt_refl_real r)
Theorem: MeasureTheory.Measure.dirac_one_mconv
File: Mathlib/MeasureTheory/Group/Convolution.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ dirac 1 ∗ μ = μ
state_after: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map (fun x => x.1 * x.2) ((dirac 1).prod μ) = μ
tactic: unfold mconv
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map (fun x => x.1 * x.2) ((dirac 1).prod μ) = μ
state_after: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map ((fun x => x.1 * x.2) ∘ Prod.mk 1) μ = μ

M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable (Prod.mk 1)
tactic: rw [MeasureTheory.Measure.dirac_prod, map_map (by fun_prop)]
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable (Prod.mk 1)
state_after: no goals
tactic: fun_prop
Theorem: Nat.not_even_one
File: Mathlib/Algebra/Group/Nat.lean

Proof steps:
state_before: m n : ℕ
⊢ ¬Even 1
state_after: no goals
tactic: simp [even_iff]
Theorem: Int.associated_iff
File: Mathlib/Algebra/GCDMonoid/Nat.lean

Proof steps:
state_before: a b : ℤ
⊢ Associated a b ↔ a = b ∨ a = -b
state_after: a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a = b ∨ a = -b
tactic: rw [Int.associated_iff_natAbs]
state_before: a b : ℤ
⊢ a.natAbs = b.natAbs ↔ a = b ∨ a = -b
state_after: no goals
tactic: exact Int.natAbs_eq_natAbs_iff
Theorem: Ordinal.toPGame_le_iff
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
⊢ a.toPGame ≤ b.toPGame → a ≤ b
state_after: a b : Ordinal.{u_1}
⊢ ¬a ≤ b → ¬a.toPGame ≤ b.toPGame
tactic: contrapose
state_before: a b : Ordinal.{u_1}
⊢ ¬a ≤ b → ¬a.toPGame ≤ b.toPGame
state_after: a b : Ordinal.{u_1}
⊢ b < a → b.toPGame ⧏ a.toPGame
tactic: rw [not_le, PGame.not_le]
state_before: a b : Ordinal.{u_1}
⊢ b < a → b.toPGame ⧏ a.toPGame
state_after: no goals
tactic: exact toPGame_lf
Theorem: Ordnode.balance_sz_dual
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l r : Ordnode α
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ (∃ l', Raised l' r.dual.size ∧ BalancedSz l' l.dual.size) ∨ ∃ r', Raised l.dual.size r' ∧ BalancedSz r.dual.size r'
state_after: α : Type u_1
l r : Ordnode α
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ (∃ l', Raised l' r.size ∧ BalancedSz l' l.size) ∨ ∃ r', Raised l.size r' ∧ BalancedSz r.size r'
tactic: rw [size_dual, size_dual]
state_before: α : Type u_1
l r : Ordnode α
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ (∃ l', Raised l' r.size ∧ BalancedSz l' l.size) ∨ ∃ r', Raised l.size r' ∧ BalancedSz r.size r'
state_after: no goals
tactic: exact
    H.symm.imp (Exists.imp fun _ => And.imp_right BalancedSz.symm)
      (Exists.imp fun _ => And.imp_right BalancedSz.symm)
Theorem: CategoryTheory.Limits.limitIsoLimitCurryCompLim_inv_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit G
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).inv ≫ limit.π G (j, k) = limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit G
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).hom ≫ (limitIsoLimitCurryCompLim G).inv ≫ limit.π G (j, k) =
    (limitIsoLimitCurryCompLim G).hom ≫ limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k
tactic: rw [← cancel_epi (limitIsoLimitCurryCompLim G).hom]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit G
inst✝ : HasLimit (curry.obj G ⋙ lim)
j : J
k : K
⊢ (limitIsoLimitCurryCompLim G).hom ≫ (limitIsoLimitCurryCompLim G).inv ≫ limit.π G (j, k) =
    (limitIsoLimitCurryCompLim G).hom ≫ limit.π (curry.obj G ⋙ lim) j ≫ limit.π ((curry.obj G).obj j) k
state_after: no goals
tactic: simp
Theorem: Orientation.oangle_sub_left_eq_arcsin_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ o.oangle (x - y) x = ↑(Real.arcsin (‖y‖ / ‖x - y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle x (x - y) = ↑(Real.arcsin (‖y‖ / ‖x - y‖))
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle x (x - y) = ↑(Real.arcsin (‖y‖ / ‖x - y‖))
state_after: no goals
tactic: exact (-o).oangle_sub_right_eq_arcsin_of_oangle_eq_pi_div_two h
Theorem: Basis.toDual_apply_right
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
i : ι
m : M
⊢ (b.toDual (b i)) m = (b.repr m) i
state_after: no goals
tactic: rw [← b.toDual_total_right, b.total_repr]
Theorem: Set.encard_le_card
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s ⊆ t
⊢ s.encard ≤ t.encard
state_after: α : Type u_1
β : Type u_2
s t : Set α
h : s ⊆ t
⊢ s.encard ≤ s.encard + (t \ s).encard
tactic: rw [← union_diff_cancel h, encard_union_eq disjoint_sdiff_right]
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s ⊆ t
⊢ s.encard ≤ s.encard + (t \ s).encard
state_after: no goals
tactic: exact le_self_add
Theorem: Matroid.freeOn_dual_eq
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ (freeOn E)✶ = loopyOn E
state_after: no goals
tactic: rw [freeOn, dual_dual]
Theorem: CircleDeg1Lift.translate_iterate
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
⊢ (⇑↑(translate (Multiplicative.ofAdd x)))^[n] = ⇑↑(translate (Multiplicative.ofAdd (↑n * x)))
state_after: no goals
tactic: rw [← coe_pow, ← Units.val_pow_eq_pow_val, translate_pow]
Theorem: conductor_subset_adjoin
File: Mathlib/NumberTheory/KummerDedekind.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x y : S
hy : y ∈ ↑(conductor R x)
⊢ y ∈ ↑(adjoin R {x})
state_after: no goals
tactic: simpa only [mul_one] using hy 1
Theorem: Finset.insert_sdiff_cancel
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∉ s
⊢ insert a s \ s = {a}
state_after: no goals
tactic: rw [insert_sdiff_of_not_mem _ ha, Finset.sdiff_self, insert_emptyc_eq]
Theorem: MeasureTheory.Integrable.integral_norm_condexpKernel
File: Mathlib/Probability/Kernel/Condexp.lean

Proof steps:
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ∫ (y : Ω), ‖f y‖ ∂(condexpKernel μ m) ω) μ
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ∫ (y : Ω), ‖f y‖ ∂((condDistrib id id μ).comap id ⋯) ω) μ
tactic: rw [condexpKernel]
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
hf_int : Integrable f μ
⊢ Integrable (fun ω => ∫ (y : Ω), ‖f y‖ ∂((condDistrib id id μ).comap id ⋯) ω) μ
state_after: no goals
tactic: convert Integrable.integral_norm_condDistrib
    (aemeasurable_id'' μ (inf_le_right : m ⊓ mΩ ≤ mΩ)) aemeasurable_id
    (hf_int.comp_snd_map_prod_id (inf_le_right : m ⊓ mΩ ≤ mΩ)) using 1
Theorem: List.prefix_append_right_inj
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ l r : List α✝
⊢ l ++ l₁ ++ r = l ++ l₂ ↔ l₁ ++ r = l₂
state_after: no goals
tactic: rw [append_assoc, append_right_inj]
Theorem: Submodule.mem_iInf
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Sort u_4
p : ι → Submodule R M
x : M
⊢ x ∈ ⨅ i, p i ↔ ∀ (i : ι), x ∈ p i
state_after: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Sort u_4
p : ι → Submodule R M
x : M
⊢ (∀ (i : ι), x ∈ ↑(p i)) ↔ ∀ (i : ι), x ∈ p i
tactic: rw [← SetLike.mem_coe, iInf_coe, Set.mem_iInter]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Sort u_4
p : ι → Submodule R M
x : M
⊢ (∀ (i : ι), x ∈ ↑(p i)) ↔ ∀ (i : ι), x ∈ p i
state_after: no goals
tactic: rfl
Theorem: IsOpen.smul_left
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
ht : IsOpen t
⊢ IsOpen (s • t)
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
ht : IsOpen t
⊢ IsOpen (⋃ a ∈ s, a • t)
tactic: rw [← iUnion_smul_set]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
ht : IsOpen t
⊢ IsOpen (⋃ a ∈ s, a • t)
state_after: no goals
tactic: exact isOpen_biUnion fun a _ => ht.smul _
Theorem: closure_eq_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
s : Set (α × α)
⊢ closure s = ⋂ V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}, V ○ s ○ V
state_after: case h.mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
s : Set (α × α)
x y : α
⊢ (x, y) ∈ closure s ↔ (x, y) ∈ ⋂ V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}, V ○ s ○ V
tactic: ext ⟨x, y⟩
state_before: case h.mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
s : Set (α × α)
x y : α
⊢ (x, y) ∈ closure s ↔ (x, y) ∈ ⋂ V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}, V ○ s ○ V
state_after: no goals
tactic: simp (config := { contextual := true }) only
    [mem_closure_iff_nhds_basis (UniformSpace.hasBasis_nhds_prod x y), mem_iInter, mem_setOf_eq,
      and_imp, mem_comp_comp, exists_prop, ← mem_inter_iff, inter_comm, Set.Nonempty]
Theorem: Nat.insert_self_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
h : n ≠ 0
⊢ insert n n.properDivisors = n.divisors
state_after: no goals
tactic: rw [divisors, properDivisors, Ico_succ_right_eq_insert_Ico (one_le_iff_ne_zero.2 h),
    Finset.filter_insert, if_pos (dvd_refl n)]
Theorem: Submonoid.prod_eq_bot_iff
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
⊢ s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥
state_after: no goals
tactic: simp only [eq_bot_iff, prod_le_iff, (gc_map_comap _).le_iff_le, comap_bot', mker_inl, mker_inr]
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.mem_carrier_iff'
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
q : ↑↑(Spec A⁰_ f).toPresheafedSpace
a : A
⊢ (∀ (i : ℕ),
      HomogeneousLocalization.mk { deg := m * i, num := ⟨(proj 𝒜 i) a ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ } ∈
        q.asIdeal) ↔
    ∀ (i : ℕ),
      Localization.mk ((proj 𝒜 i) a ^ m) ⟨f ^ i, ⋯⟩ ∈ ⇑(algebraMap (A⁰_ f) (Localization.Away f)) '' {s | s ∈ q.asIdeal}
state_after: case mp
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
q : ↑↑(Spec A⁰_ f).toPresheafedSpace
a : A
i : ℕ
h :
  HomogeneousLocalization.mk { deg := m * i, num := ⟨(proj 𝒜 i) a ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ } ∈ q.asIdeal
⊢ Localization.mk ((proj 𝒜 i) a ^ m) ⟨f ^ i, ⋯⟩ ∈ ⇑(algebraMap (A⁰_ f) (Localization.Away f)) '' {s | s ∈ q.asIdeal}

case mpr
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
q : ↑↑(Spec A⁰_ f).toPresheafedSpace
a : A
i : ℕ
h : Localization.mk ((proj 𝒜 i) a ^ m) ⟨f ^ i, ⋯⟩ ∈ ⇑(algebraMap (A⁰_ f) (Localization.Away f)) '' {s | s ∈ q.asIdeal}
⊢ HomogeneousLocalization.mk { deg := m * i, num := ⟨(proj 𝒜 i) a ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ } ∈ q.asIdeal
tactic: constructor <;> intro h i <;> specialize h i
Theorem: LinearMap.toMvPolynomial_baseChange
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Fintype ι₁
inst✝³ : Finite ι₂
inst✝² : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
f : M₁ →ₗ[R] M₂
i : ι₂
A : Type u_6
inst✝¹ : CommRing A
inst✝ : Algebra R A
⊢ toMvPolynomial (basis A b₁) (basis A b₂) (baseChange A f) i =
    (MvPolynomial.map (algebraMap R A)) (toMvPolynomial b₁ b₂ f i)
state_after: no goals
tactic: simp only [toMvPolynomial, toMatrix_baseChange, Matrix.toMvPolynomial_map]
Theorem: CategoryTheory.Quotient.compClosure_eq_self
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
⊢ CompClosure r = r
state_after: case h.h.h.h.a
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
x✝³ x✝² : C
x✝¹ x✝ : x✝³ ⟶ x✝²
⊢ CompClosure r x✝¹ x✝ ↔ r x✝¹ x✝
tactic: ext
state_before: case h.h.h.h.a
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
x✝³ x✝² : C
x✝¹ x✝ : x✝³ ⟶ x✝²
⊢ CompClosure r x✝¹ x✝ ↔ r x✝¹ x✝
state_after: no goals
tactic: simp only [compClosure_iff_self]
Theorem: Num.mem_ofZNum'
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m : Num
p : PosNum
⊢ pos p = m ↔ ZNum.pos p = m.toZNum
state_after: no goals
tactic: cases m <;> constructor <;> intro h <;> try cases h <;> rfl
state_before: α : Type u_1
m : Num
p : PosNum
h : ZNum.neg p = m.toZNum
⊢ m ∈ ofZNum' (ZNum.neg p)
state_after: no goals
tactic: cases m <;> cases h
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f la' volume
hf : Tendsto f (la' ⊓ ae volume) (𝓝 c)
hu : Tendsto u lt la
hv : Tendsto v lt la
⊢ (fun t => ((∫ (x : ℝ) in v t..b, f x) - ∫ (x : ℝ) in u t..b, f x) + (v t - u t) • c) =o[lt] (v - u)
state_after: no goals
tactic: simpa only [integral_const, smul_eq_mul, mul_one] using
    measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_left hab hmeas hf hu hv
Theorem: HurwitzZeta.hasSum_expZeta_of_one_lt_re
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) (expZeta (↑a) s)
state_after: case h.e'_5
a : ℝ
s : ℂ
hs : 1 < s.re
⊢ (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) = fun b =>
    ↑(Real.cos (2 * π * a * ↑b)) / ↑b ^ s + I * (↑(Real.sin (2 * π * a * ↑b)) / ↑b ^ s)
tactic: convert (hasSum_nat_cosZeta a hs).add ((hasSum_nat_sinZeta a hs).mul_left I) using 1
state_before: case h.e'_5
a : ℝ
s : ℂ
hs : 1 < s.re
⊢ (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s) = fun b =>
    ↑(Real.cos (2 * π * a * ↑b)) / ↑b ^ s + I * (↑(Real.sin (2 * π * a * ↑b)) / ↑b ^ s)
state_after: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s =
    ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s + I * (↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s)
tactic: ext1 n
state_before: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑n ^ s =
    ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s + I * (↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s)
state_after: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (Complex.cos (2 * ↑π * ↑a * ↑n) + Complex.sin (2 * ↑π * ↑a * ↑n) * I) / ↑n ^ s =
    Complex.cos (2 * ↑π * ↑a * ↑n) / ↑n ^ s + I * (Complex.sin (2 * ↑π * ↑a * ↑n) / ↑n ^ s)
tactic: simp only [mul_right_comm _ I, ← cos_add_sin_I, push_cast]
state_before: case h.e'_5.h
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ (Complex.cos (2 * ↑π * ↑a * ↑n) + Complex.sin (2 * ↑π * ↑a * ↑n) * I) / ↑n ^ s =
    Complex.cos (2 * ↑π * ↑a * ↑n) / ↑n ^ s + I * (Complex.sin (2 * ↑π * ↑a * ↑n) / ↑n ^ s)
state_after: no goals
tactic: rw [add_div, mul_div, mul_comm _ I]
Theorem: Subspace.dualRestrict_comp_dualLift
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
⊢ dualRestrict W ∘ₗ W.dualLift = 1
state_after: case h.h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
φ : Module.Dual K ↥W
x : ↥W
⊢ ((dualRestrict W ∘ₗ W.dualLift) φ) x = (1 φ) x
tactic: ext φ x
state_before: case h.h
K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
φ : Module.Dual K ↥W
x : ↥W
⊢ ((dualRestrict W ∘ₗ W.dualLift) φ) x = (1 φ) x
state_after: no goals
tactic: simp
Theorem: Ideal.iInf_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι✝ : Type u_1
inst✝¹ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_2
inst✝ : Fintype ι
I : ι → R
hI : ∀ (i j : ι), i ≠ j → IsCoprime (I i) (I j)
⊢ ⨅ i, span {I i} = span {∏ i : ι, I i}
state_after: case hI
R : Type u
ι✝ : Type u_1
inst✝¹ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_2
inst✝ : Fintype ι
I : ι → R
hI : ∀ (i j : ι), i ≠ j → IsCoprime (I i) (I j)
⊢ (↑Finset.univ).Pairwise (IsCoprime on I)
tactic: rw [← Finset.inf_univ_eq_iInf, finset_inf_span_singleton]
state_before: case hI
R : Type u
ι✝ : Type u_1
inst✝¹ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_2
inst✝ : Fintype ι
I : ι → R
hI : ∀ (i j : ι), i ≠ j → IsCoprime (I i) (I j)
⊢ (↑Finset.univ).Pairwise (IsCoprime on I)
state_after: no goals
tactic: rwa [Finset.coe_univ, Set.pairwise_univ]