ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isPreconnected_of_forall
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected s
state_after: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u✝ v✝ s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
⊢ (s ∩ (u ∩ v)).Nonempty
tactic: rintro u v hu hv hs ⟨z, zs, zu⟩ ⟨y, ys, yv⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u✝ v✝ s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
⊢ (s ∩ (u ∩ v)).Nonempty
state_after: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u✝ v✝ s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
xs : x ∈ s
⊢ (s ∩ (u ∩ v)).Nonempty
tactic: have xs : x ∈ s := by
    rcases H y ys with ⟨t, ts, xt, -, -⟩
    exact ts xt
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u✝ v✝ s : Set α
x : α
H : ∀ y ∈ s, ∃ t ⊆ s, x ∈ t ∧ y ∈ t ∧ IsPreconnected t
u v : Set α
hu : IsOpen u
hv : IsOpen v
hs : s ⊆ u ∪ v
z : α
zs : z ∈ s
zu : z ∈ u
y : α
ys : y ∈ s
yv : y ∈ v
xs : x ∈ s
⊢ (s ∩ (u ∩ v)).Nonempty
state_after: no goals
tactic: cases hs xs with
  | inl xu =>
    rcases H y ys with ⟨t, ts, xt, yt, ht⟩
    have := ht u v hu hv (ts.trans hs) ⟨x, xt, xu⟩ ⟨y, yt, yv⟩
    exact this.imp fun z hz => ⟨ts hz.1, hz.2⟩
  | inr xv =>
    rcases H z zs with ⟨t, ts, xt, zt, ht⟩
    have := ht v u hv hu (ts.trans <| by rwa [union_comm]) ⟨x, xt, xv⟩ ⟨z, zt, zu⟩
    exact this.imp fun _ h => ⟨ts h.1, h.2.2, h.2.1⟩
Theorem: IsAddUnit.isAddUnit_iff_addRight_bijective
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a✝ b c a : M
h : IsUnit a
y : M
⊢ (fun x => x * a) (y * ↑h.unit⁻¹) = y
state_after: no goals
tactic: simp [mul_assoc]
Theorem: Mod_.id_hom'
File: Mathlib/CategoryTheory/Monoidal/Mod_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
A : Mon_ C
M✝ M : Mod_ A
⊢ (𝟙 M).hom = 𝟙 M.X
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.StructureSheaf.comap_const
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
hUV : V.carrier ⊆ ⇑(PrimeSpectrum.comap f) ⁻¹' U.carrier
a b : R
hb : ∀ x ∈ U, b ∈ x.asIdeal.primeCompl
p : ↥(unop (op V))
⊢ ↑((comap f U V hUV) (const R a b U hb)) p = ↑(const S (f a) (f b) V ⋯) p
state_after: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
hUV : V.carrier ⊆ ⇑(PrimeSpectrum.comap f) ⁻¹' U.carrier
a b : R
hb : ∀ x ∈ U, b ∈ x.asIdeal.primeCompl
p : ↥(unop (op V))
⊢ (Localization.localRingHom ((PrimeSpectrum.comap f) ↑p).asIdeal (↑p).asIdeal f ⋯)
      (IsLocalization.mk' (Localizations R ↑⟨(PrimeSpectrum.comap f) ↑p, ⋯⟩) a ⟨b, ⋯⟩) =
    IsLocalization.mk' (Localizations S ↑p) (f a) ⟨f b, ⋯⟩
tactic: rw [comap_apply, const_apply, const_apply]
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
hUV : V.carrier ⊆ ⇑(PrimeSpectrum.comap f) ⁻¹' U.carrier
a b : R
hb : ∀ x ∈ U, b ∈ x.asIdeal.primeCompl
p : ↥(unop (op V))
⊢ (Localization.localRingHom ((PrimeSpectrum.comap f) ↑p).asIdeal (↑p).asIdeal f ⋯)
      (IsLocalization.mk' (Localizations R ↑⟨(PrimeSpectrum.comap f) ↑p, ⋯⟩) a ⟨b, ⋯⟩) =
    IsLocalization.mk' (Localizations S ↑p) (f a) ⟨f b, ⋯⟩
state_after: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
hUV : V.carrier ⊆ ⇑(PrimeSpectrum.comap f) ⁻¹' U.carrier
a b : R
hb : ∀ x ∈ U, b ∈ x.asIdeal.primeCompl
p : ↥(unop (op V))
⊢ IsLocalization.mk' (Localization.AtPrime (↑p).asIdeal) (f a) ⟨f ↑⟨b, ⋯⟩, ⋯⟩ =
    IsLocalization.mk' (Localizations S ↑p) (f a) ⟨f b, ⋯⟩
tactic: erw [Localization.localRingHom_mk']
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
hUV : V.carrier ⊆ ⇑(PrimeSpectrum.comap f) ⁻¹' U.carrier
a b : R
hb : ∀ x ∈ U, b ∈ x.asIdeal.primeCompl
p : ↥(unop (op V))
⊢ IsLocalization.mk' (Localization.AtPrime (↑p).asIdeal) (f a) ⟨f ↑⟨b, ⋯⟩, ⋯⟩ =
    IsLocalization.mk' (Localizations S ↑p) (f a) ⟨f b, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: SetLike.list_prod_ofFn_mem_graded
File: Mathlib/Algebra/GradedMonoid.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.ofFn r).prod ∈ A (List.ofFn i).sum
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.map r (List.finRange n)).prod ∈ A (List.map i (List.finRange n)).sum
tactic: rw [List.ofFn_eq_map, List.ofFn_eq_map]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ (List.map r (List.finRange n)).prod ∈ A (List.map i (List.finRange n)).sum
state_after: no goals
tactic: exact list_prod_map_mem_graded _ _ _ fun _ _ => h _
Theorem: Option.pbind_eq_bind
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : α → Option β
x : Option α
⊢ (x.pbind fun a x => f a) = x.bind f
state_after: no goals
tactic: cases x <;> simp only [pbind, none_bind', some_bind']
Theorem: Fin.exists_succAbove_eq
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
⊢ ∃ z, y.succAbove z = x
state_after: case inl
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hxy : x < y
⊢ ∃ z, y.succAbove z = x

case inr
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hyx : y < x
⊢ ∃ z, y.succAbove z = x
tactic: obtain hxy | hyx := Fin.lt_or_lt_of_ne h
state_before: case inl
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hxy : x < y
⊢ ∃ z, y.succAbove z = x

case inr
n m : ℕ
p : Fin (n + 1)
i j : Fin n
x y : Fin (n + 1)
h : x ≠ y
hyx : y < x
⊢ ∃ z, y.succAbove z = x
state_after: no goals
tactic: exacts [⟨_, succAbove_castPred_of_lt _ _ hxy⟩, ⟨_, succAbove_pred_of_lt _ _ hyx⟩]
Theorem: MeasureTheory.Measure.dirac_apply
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
⊢ (dirac a) s = s.indicator 1 a
state_after: case pos
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∈ s
⊢ (dirac a) s = s.indicator 1 a

case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∉ s
⊢ (dirac a) s = s.indicator 1 a
tactic: by_cases h : a ∈ s
state_before: case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∉ s
⊢ (dirac a) s = s.indicator 1 a
state_after: case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∉ s
⊢ (dirac a) s ≤ 0
tactic: rw [indicator_of_not_mem h, ← nonpos_iff_eq_zero]
state_before: case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s✝ : Set α
a✝ : α
inst✝ : MeasurableSingletonClass α
a : α
s : Set α
h : a ∉ s
⊢ (dirac a) s ≤ 0
state_after: no goals
tactic: calc
    dirac a s ≤ dirac a {a}ᶜ := measure_mono (subset_compl_comm.1 <| singleton_subset_iff.2 h)
    _ = 0 := by simp [dirac_apply' _ (measurableSet_singleton _).compl]
Theorem: Nat.filter_dvd_eq_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
h : n ≠ 0
⊢ filter (fun x => x ∣ n) (range n) = n.properDivisors
state_after: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∈ filter (fun x => x ∣ n) (range n) ↔ a✝ ∈ n.properDivisors
tactic: ext
state_before: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∈ filter (fun x => x ∣ n) (range n) ↔ a✝ ∈ n.properDivisors
state_after: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∣ n → a✝ < n → 1 ≤ a✝
tactic: simp only [properDivisors, mem_filter, mem_range, mem_Ico, and_congr_left_iff, iff_and_self]
state_before: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∣ n → a✝ < n → 1 ≤ a✝
state_after: no goals
tactic: exact fun ha _ => succ_le_iff.mpr (pos_of_dvd_of_pos ha h.bot_lt)
Theorem: Function.Commute.iterate_eq_of_map_eq
File: Mathlib/Logic/Function/Iterate.lean

Proof steps:
state_before: α : Type u
β : Type v
f g : α → α
h : Commute f g
n✝ : ℕ
x : α
hx : f x = g x
n : ℕ
ihn : f^[n] x = g^[n] x
⊢ f^[n.succ] x = g^[n.succ] x
state_after: no goals
tactic: simp only [iterate_succ_apply, hx, (h.iterate_left n).eq, ihn, ((refl g).iterate_right n).eq]
Theorem: Ideal.minimalPrimes_eq_subsingleton_self
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I J : Ideal R
inst✝ : I.IsPrime
⊢ I.minimalPrimes = {I}
state_after: case h
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : I.IsPrime
J : Ideal R
⊢ J ∈ I.minimalPrimes ↔ J ∈ {I}
tactic: ext J
state_before: case h
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : I.IsPrime
J : Ideal R
⊢ J ∈ I.minimalPrimes ↔ J ∈ {I}
state_after: case h.mp
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : I.IsPrime
J : Ideal R
⊢ J ∈ I.minimalPrimes → J ∈ {I}

case h.mpr
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
I J✝ : Ideal R
inst✝ : I.IsPrime
J : Ideal R
⊢ J ∈ {I} → J ∈ I.minimalPrimes
tactic: constructor
Theorem: ProbabilityTheory.Kernel.compProd_null
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ ((κ ⊗ₖ η) a) s = 0 ↔ (fun b => (η (a, b)) (Prod.mk b ⁻¹' s)) =ᶠ[ae (κ a)] 0
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ (fun b => (η (a, b)) {c | (b, c) ∈ s}) =ᶠ[ae (κ a)] 0 ↔ (fun b => (η (a, b)) (Prod.mk b ⁻¹' s)) =ᶠ[ae (κ a)] 0

α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ Measurable fun b => (η (a, b)) {c | (b, c) ∈ s}
tactic: rw [Kernel.compProd_apply _ _ _ hs, lintegral_eq_zero_iff]
Theorem: Filter.prod_assoc_symm
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
h : Filter γ
⊢ map (⇑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) = (f ×ˢ g) ×ˢ h
state_after: no goals
tactic: simp_rw [map_equiv_symm, SProd.sprod, Filter.prod, comap_inf, comap_comap, inf_assoc,
    Function.comp, Equiv.prodAssoc_apply]
Theorem: CochainComplex.shiftShortComplexFunctorIso_hom_app_τ₃
File: Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).prev i = (up ℤ).prev i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
tactic: simp only [prev]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
state_after: no goals
tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).next i = (up ℤ).next i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
tactic: simp only [next]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
state_after: no goals
tactic: omega
Theorem: Fintype.exists_unique_iff_card_one
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
⊢ (∃! a, p a) ↔ (filter p univ).card = 1
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
⊢ (∃! a, p a) ↔ ∃ a, filter p univ = {a}
tactic: rw [Finset.card_eq_one]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
⊢ (∃! a, p a) ↔ ∃ a, filter p univ = {a}
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ ((fun a => p a) x ∧ ∀ (y : α), (fun a => p a) y → y = x) ↔ filter p univ = {x}
tactic: refine exists_congr fun x => ?_
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β
α : Type u_4
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ ((fun a => p a) x ∧ ∀ (y : α), (fun a => p a) y → y = x) ↔ filter p univ = {x}
state_after: no goals
tactic: simp only [forall_true_left, Subset.antisymm_iff, subset_singleton_iff', singleton_subset_iff,
      true_and, and_comm, mem_univ, mem_filter]
Theorem: CategoryTheory.IsPullback.of_id_fst
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
⊢ 𝟙 X ≫ f = f ≫ 𝟙 Z
state_after: no goals
tactic: simp
Theorem: TypeVec.dropFun_prod
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α α' β β' : TypeVec.{u_1} (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
⊢ dropFun (f ⊗' f') = (dropFun f ⊗' dropFun f')
state_after: case a.h
n : ℕ
α α' β β' : TypeVec.{u_1} (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
i : Fin2 n
x✝ : (α ⊗ α').drop i
⊢ dropFun (f ⊗' f') i x✝ = (dropFun f ⊗' dropFun f') i x✝
tactic: ext i : 2
state_before: case a.h
n : ℕ
α α' β β' : TypeVec.{u_1} (n + 1)
f : α ⟹ β
f' : α' ⟹ β'
i : Fin2 n
x✝ : (α ⊗ α').drop i
⊢ dropFun (f ⊗' f') i x✝ = (dropFun f ⊗' dropFun f') i x✝
state_after: no goals
tactic: induction i <;> simp [dropFun, *] <;> rfl
Theorem: Int.log_of_right_le_one
File: Mathlib/Data/Int/Log.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 1
⊢ log b r = -↑(Nat.clog b ⌈r⁻¹⌉₊)
state_after: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hr : 1 ≤ 1
⊢ log b 1 = -↑(Nat.clog b ⌈1⁻¹⌉₊)

case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr✝ : r ≤ 1
hr : r < 1
⊢ log b r = -↑(Nat.clog b ⌈r⁻¹⌉₊)
tactic: obtain rfl | hr := hr.eq_or_lt
Theorem: tendstoUniformlyOn_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F✝ : ι → α → β
f✝ : α → β
s✝ s' : Set α
x : α
p✝ : Filter ι
p' : Filter α
g : ι → α
F : ι → α → β
f : α → β
p : Filter ι
s : Set α
⊢ TendstoUniformlyOn F f p s ↔ Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ 𝓟 s) (𝓤 β)
state_after: no goals
tactic: simp [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto]
Theorem: sub_sub_sub_cancel_right
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✝ : Group G
a✝ b✝ c✝ d : G
n : ℤ
a b c : G
⊢ a / c / (b / c) = a / b
state_after: no goals
tactic: rw [← inv_div c b, div_inv_eq_mul, div_mul_div_cancel']
Theorem: ZNum.zneg_bitm1
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : ZNum
⊢ -n.bitm1 = (-n).bit1
state_after: no goals
tactic: cases n <;> rfl
Theorem: SimpleGraph.mem_incidenceSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
v w : V
⊢ s(v, w) ∈ G.incidenceSet v ↔ G.Adj v w
state_after: no goals
tactic: simp [incidenceSet]
Theorem: Commute.inv_mul_cancel
File: Mathlib/Algebra/Group/Commute/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a⁻¹ * b * a = b
state_after: no goals
tactic: rw [h.inv_left.eq, inv_mul_cancel_right]
Theorem: MeasureTheory.lintegral_add_right'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g μ
⊢ ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ
state_after: no goals
tactic: simpa only [add_comm] using lintegral_add_left' hg f
Theorem: Option.pmap_bind
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
δ : Type u_4
p✝ : α✝ → Prop
f✝ : (a : α✝) → p✝ a → β✝
x✝ : Option α✝
α β γ : Type u_5
x : Option α
g : α → Option β
p : β → Prop
f : (b : β) → p b → γ
H : ∀ (a : β), a ∈ x >>= g → p a
H' : ∀ (a : α) (b : β), b ∈ g a → b ∈ x >>= g
⊢ pmap f (x >>= g) H = do
    let a ← x
    pmap f (g a) ⋯
state_after: no goals
tactic: cases x <;> simp only [pmap, bind_eq_bind, none_bind, some_bind]
Theorem: Nat.sqrt_add_eq
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
h : a ≤ n + n
⊢ n * n + a < n.succ * n.succ
state_after: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
h : a ≤ n + n
⊢ n * n + a < (n * n + (n + n)).succ
tactic: rw [succ_mul, mul_succ, add_succ, Nat.add_assoc]
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
h : a ≤ n + n
⊢ n * n + a < (n * n + (n + n)).succ
state_after: no goals
tactic: exact lt_succ_of_le (Nat.add_le_add_left h _)
Theorem: associatedPrimes.nonempty
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
⊢ (associatedPrimes R M).Nonempty
state_after: case intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
⊢ (associatedPrimes R M).Nonempty
tactic: obtain ⟨x, hx⟩ := exists_ne (0 : M)
state_before: case intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
⊢ (associatedPrimes R M).Nonempty
state_after: case intro.intro.intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
P : Ideal R
hP : IsAssociatedPrime P M
right✝ : (Submodule.span R {x}).annihilator ≤ P
⊢ (associatedPrimes R M).Nonempty
tactic: obtain ⟨P, hP, _⟩ := exists_le_isAssociatedPrime_of_isNoetherianRing R x hx
state_before: case intro.intro.intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
P : Ideal R
hP : IsAssociatedPrime P M
right✝ : (Submodule.span R {x}).annihilator ≤ P
⊢ (associatedPrimes R M).Nonempty
state_after: no goals
tactic: exact ⟨P, hP⟩
Theorem: minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
x : E
⊢ (minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = (expand F (q ^ n)) (X - C y)
state_after: case refine_1
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
x : E
h : (minpoly F x).natSepDegree = 1
⊢ ∃ n y, minpoly F x = (expand F (q ^ n)) (X - C y)

case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
x : E
x✝ : ∃ n y, minpoly F x = (expand F (q ^ n)) (X - C y)
n : ℕ
y : F
h : minpoly F x = (expand F (q ^ n)) (X - C y)
⊢ (minpoly F x).natSepDegree = 1
tactic: refine ⟨fun h ↦ ?_, fun ⟨n, y, h⟩ ↦ ?_⟩
state_before: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
x : E
x✝ : ∃ n y, minpoly F x = (expand F (q ^ n)) (X - C y)
n : ℕ
y : F
h : minpoly F x = (expand F (q ^ n)) (X - C y)
⊢ (minpoly F x).natSepDegree = 1
state_after: no goals
tactic: rw [h, natSepDegree_expand _ q, natSepDegree_X_sub_C]
Theorem: ZMod.val_eq_zero
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a : ZMod (n + 1)
⊢ a.val = 0 ↔ a = 0
state_after: m n✝ n : ℕ
a : ZMod (n + 1)
⊢ a.val = 0 ↔ ↑a = ↑0
tactic: rw [Fin.ext_iff]
state_before: m n✝ n : ℕ
a : ZMod (n + 1)
⊢ a.val = 0 ↔ ↑a = ↑0
state_after: no goals
tactic: exact Iff.rfl