ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: nhdsWithin_Ici_eq''
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
⊢ 𝓝[≥] a = (⨅ u, ⨅ (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a)
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
⊢ ((⨅ b ∈ Iio a, 𝓟 (Ioi b)) ⊓ ⨅ b ∈ Ioi a, 𝓟 (Iio b)) ⊓ 𝓟 (Ici a) = (⨅ u, ⨅ (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a)
tactic: rw [nhdsWithin, nhds_eq_order]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
⊢ ((⨅ b ∈ Iio a, 𝓟 (Ioi b)) ⊓ ⨅ b ∈ Ioi a, 𝓟 (Iio b)) ⊓ 𝓟 (Ici a) = (⨅ u, ⨅ (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a)
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
⊢ (⨅ u, ⨅ (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a) ≤ ⨅ b ∈ Iio a, 𝓟 (Ioi b)
tactic: refine le_antisymm (inf_le_inf_right _ inf_le_right) (le_inf (le_inf ?_ inf_le_left) inf_le_right)
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
⊢ (⨅ u, ⨅ (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a) ≤ ⨅ b ∈ Iio a, 𝓟 (Ioi b)
state_after: no goals
tactic: exact inf_le_right.trans (le_iInf₂ fun l hl => principal_mono.2 <| Ici_subset_Ioi.2 hl)
Theorem: Finset.supIndep_pair
File: Mathlib/Order/SupIndep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : {i, j}.SupIndep f
⊢ i ∈ ↑{i, j}
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : {i, j}.SupIndep f
⊢ j ∈ ↑{i, j}
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
⊢ {i, j}.SupIndep f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
⊢ ∀ i_1 ∈ {i, j}, Disjoint (f i_1) (({i, j}.erase i_1).sup f)
tactic: rw [supIndep_iff_disjoint_erase]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
⊢ ∀ i_1 ∈ {i, j}, Disjoint (f i_1) (({i, j}.erase i_1).sup f)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
k : ι
hk : k ∈ {i, j}
⊢ Disjoint (f k) (({i, j}.erase k).sup f)
tactic: intro k hk
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
k : ι
hk : k ∈ {i, j}
⊢ Disjoint (f k) (({i, j}.erase k).sup f)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
k : ι
hk : k = i ∨ k = j
⊢ Disjoint (f k) (({i, j}.erase k).sup f)
tactic: rw [Finset.mem_insert, Finset.mem_singleton] at hk
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
h : Disjoint (f i) (f j)
k : ι
hk : k = i ∨ k = j
⊢ Disjoint (f k) (({i, j}.erase k).sup f)
state_after: case inl
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i : ι
inst✝ : DecidableEq ι
j k : ι
hij : k ≠ j
h : Disjoint (f k) (f j)
⊢ Disjoint (f k) (({k, j}.erase k).sup f)

case inr
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : Lattice α
inst✝¹ : OrderBot α
s t : Finset ι
f : ι → α
i✝ : ι
inst✝ : DecidableEq ι
i k : ι
hij : i ≠ k
h : Disjoint (f i) (f k)
⊢ Disjoint (f k) (({i, k}.erase k).sup f)
tactic: obtain rfl | rfl := hk
Theorem: List.mem_traverse
File: Mathlib/Control/Traversable/Instances.lean

Proof steps:
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
⊢ [] ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) [] []
state_after: no goals
tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
⊢ [] ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) [] (a :: as)
state_after: no goals
tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) []
state_after: no goals
tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) (a :: as)
state_after: no goals
tactic: simp [mem_traverse as bs]
Theorem: List.Nodup.getElem_inj_iff
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : l.Nodup
i : ℕ
hi : i < l.length
j : ℕ
hj : j < l.length
⊢ l[i] = l[j] ↔ i = j
state_after: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : l.Nodup
i : ℕ
hi : i < l.length
j : ℕ
hj : j < l.length
this : l.get ⟨i, hi⟩ = l.get ⟨j, hj⟩ ↔ ⟨i, hi⟩ = ⟨j, hj⟩
⊢ l[i] = l[j] ↔ i = j
tactic: have := @Nodup.get_inj_iff _ _ h ⟨i, hi⟩ ⟨j, hj⟩
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : l.Nodup
i : ℕ
hi : i < l.length
j : ℕ
hj : j < l.length
this : l.get ⟨i, hi⟩ = l.get ⟨j, hj⟩ ↔ ⟨i, hi⟩ = ⟨j, hj⟩
⊢ l[i] = l[j] ↔ i = j
state_after: no goals
tactic: simpa
Theorem: MeasurableSpace.measurableSet_iInf
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 : Set α
ι : Sort u_7
m : ι → MeasurableSpace α
s : Set α
⊢ MeasurableSet s ↔ ∀ (i : ι), MeasurableSet s
state_after: no goals
tactic: rw [iInf, measurableSet_sInf, forall_mem_range]
Theorem: Nat.prod_primeFactors_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p n : ℕ
⊢ ∏ p ∈ n.primeFactors, p ∣ n
state_after: case pos
a b m n✝ p n : ℕ
hn : n = 0
⊢ ∏ p ∈ n.primeFactors, p ∣ n

case neg
a b m n✝ p n : ℕ
hn : ¬n = 0
⊢ ∏ p ∈ n.primeFactors, p ∣ n
tactic: by_cases hn : n = 0
Theorem: compl_top
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : HeytingAlgebra α
a✝ b c a : α
⊢ a ≤ ⊤ᶜ ↔ a ≤ ⊥
state_after: no goals
tactic: rw [le_compl_iff_disjoint_right, disjoint_top, le_bot_iff]
Theorem: Int.rel_of_forall_rel_succ_of_lt
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a b : ℤ
hab : a < b
⊢ r (f a) (f b)
state_after: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
n : ℕ
hab : a < a + ↑n.succ
⊢ r (f a) (f (a + ↑n.succ))
tactic: rcases lt.dest hab with ⟨n, rfl⟩
state_before: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
n : ℕ
hab : a < a + ↑n.succ
⊢ r (f a) (f (a + ↑n.succ))
state_after: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
n : ℕ
⊢ r (f a) (f (a + ↑n.succ))
tactic: clear hab
state_before: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
n : ℕ
⊢ r (f a) (f (a + ↑n.succ))
state_after: case intro.zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
⊢ r (f a) (f (a + ↑(Nat.succ 0)))

case intro.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r✝ : α → α → Prop
inst✝¹ : Preorder α
r : β → β → Prop
inst✝ : IsTrans β r
f : ℤ → β
h : ∀ (n : ℤ), r (f n) (f (n + 1))
a : ℤ
n : ℕ
ihn : r (f a) (f (a + ↑n.succ))
⊢ r (f a) (f (a + ↑(n + 1).succ))
tactic: induction' n with n ihn
Theorem: Nat.not_dvd_iff_between_consec_multiples
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
n a : ℕ
ha : 0 < a
⊢ (∃ k, a * k < n ∧ n < a * (k + 1)) ↔ ¬a ∣ n
state_after: a✝ b c d m n✝ k : ℕ
p q : ℕ → Prop
n a : ℕ
ha : 0 < a
han : ¬a ∣ n
⊢ a * (n / a) ≠ n
tactic: refine
    ⟨fun ⟨k, hk1, hk2⟩ => not_dvd_of_between_consec_multiples hk1 hk2, fun han =>
      ⟨n / a, ⟨lt_of_le_of_ne (mul_div_le n a) ?_, lt_mul_div_succ _ ha⟩⟩⟩
Theorem: Rel.comp_right_id
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ r • Eq = r
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ (fun x z => ∃ y, r x y ∧ y = z) = r
tactic: unfold comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
⊢ (fun x z => ∃ y, r x y ∧ y = z) = r
state_after: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
y : α
x✝ : β
⊢ (∃ y_1, r y y_1 ∧ y_1 = x✝) ↔ r y x✝
tactic: ext y
state_before: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r : Rel α β
y : α
x✝ : β
⊢ (∃ y_1, r y y_1 ∧ y_1 = x✝) ↔ r y x✝
state_after: no goals
tactic: simp
Theorem: EuclideanGeometry.Sphere.oangle_eq_pi_sub_two_zsmul_oangle_center_left
File: Mathlib/Geometry/Euclidean/Angle/Sphere.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
s : Sphere P
p₁ p₂ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
h : p₁ ≠ p₂
⊢ ∡ p₁ s.center p₂ = ↑π - 2 • ∡ s.center p₂ p₁
state_after: no goals
tactic: rw [oangle_eq_pi_sub_two_zsmul_oangle_of_dist_eq h.symm
      (dist_center_eq_dist_center_of_mem_sphere' hp₂ hp₁)]
Theorem: Lagrange.interpolate_one
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ (interpolate s v) 1 = 1
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ x ∈ s, Lagrange.basis s v x = 1
tactic: simp_rw [interpolate_apply, Pi.one_apply, map_one, one_mul]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ x ∈ s, Lagrange.basis s v x = 1
state_after: no goals
tactic: exact sum_basis hvs hs
Theorem: Ideal.maximal_of_no_maximal
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
P : Ideal α
hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal
J : Ideal α
hPJ : P < J
⊢ J = ⊤
state_after: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
P : Ideal α
hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal
J : Ideal α
hPJ : P < J
hnonmax : ¬J = ⊤
⊢ False
tactic: by_contra hnonmax
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
P : Ideal α
hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal
J : Ideal α
hPJ : P < J
hnonmax : ¬J = ⊤
⊢ False
state_after: case intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
P : Ideal α
hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal
J : Ideal α
hPJ : P < J
hnonmax : ¬J = ⊤
M : Ideal α
hM1 : M.IsMaximal
hM2 : J ≤ M
⊢ False
tactic: rcases exists_le_maximal J hnonmax with ⟨M, hM1, hM2⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
P : Ideal α
hmax : ∀ (m : Ideal α), P < m → ¬m.IsMaximal
J : Ideal α
hPJ : P < J
hnonmax : ¬J = ⊤
M : Ideal α
hM1 : M.IsMaximal
hM2 : J ≤ M
⊢ False
state_after: no goals
tactic: exact hmax M (lt_of_lt_of_le hPJ hM2) hM1
Theorem: Primrec₂.of_eq
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
⊢ f = g
state_after: case h.h
α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
a : α
b : β
⊢ f a b = g a b
tactic: funext a b
state_before: case h.h
α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
a : α
b : β
⊢ f a b = g a b
state_after: no goals
tactic: apply H
Theorem: FinEnum.Finset.mem_enum
File: Mathlib/Data/FinEnum.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finset α
xs : List α
⊢ s ∈ enum xs ↔ ∀ x ∈ s, x ∈ xs
state_after: case nil
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finset α
⊢ s = ∅ ↔ ∀ (x : α), x ∉ s

case cons
α : Type u
β : α → Type v
inst✝ : DecidableEq α
xs_hd : α
tail✝ : List α
tail_ih✝ : ∀ (s : Finset α), s ∈ enum tail✝ ↔ ∀ x ∈ s, x ∈ tail✝
s : Finset α
⊢ (∃ a, (∀ x ∈ a, x ∈ tail✝) ∧ (s = a ∨ s = {xs_hd} ∪ a)) ↔ ∀ x ∈ s, x = xs_hd ∨ x ∈ tail✝
tactic: induction' xs with xs_hd generalizing s <;> simp [*, Finset.enum]
Theorem: Complex.cpow_natCast
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x : ℂ
n : ℕ
⊢ x ^ ↑n = x ^ n
state_after: no goals
tactic: simpa using cpow_nat_mul x n 1
Theorem: FiniteInter.mk₂
File: Mathlib/Data/Set/Constructions.lean

Proof steps:
state_before: α : Type u_1
S : Set (Set α)
h : ∀ ⦃s : Set α⦄, s ∈ S → ∀ ⦃t : Set α⦄, t ∈ S → s ∩ t ∈ S
s : Set α
hs : s ∈ insert univ S
t : Set α
ht : t ∈ insert univ S
⊢ s ∩ t ∈ insert univ S
state_after: no goals
tactic: aesop
Theorem: Filter.HasBasis.cauchySeq_iff'
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
H : (𝓤 α).HasBasis p s
⊢ CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i
state_after: case refine_1
α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
H : (𝓤 α).HasBasis p s
h : ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
i : γ
hi : p i
⊢ ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i

case refine_2
α : Type u
β : Type v
uniformSpace : UniformSpace α
γ : Sort u_1
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
u : β → α
p : γ → Prop
s : γ → Set (α × α)
H : (𝓤 α).HasBasis p s
h : ∀ (i : γ), p i → ∃ N, ∀ n ≥ N, (u n, u N) ∈ s i
i : γ
hi : p i
⊢ ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i
tactic: refine H.cauchySeq_iff.trans ⟨fun h i hi => ?_, fun h i hi => ?_⟩
Theorem: powCoprime_symm_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key :
  (fun x => g ^ x) ↑((Nat.card G).gcd n) =
    (fun x => g ^ x) (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ (Nat.card G).gcdB n) ((fun g => g ^ n) g) = g
state_after: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key : g ^ ↑((Nat.card G).gcd n) = g ^ (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ (Nat.card G).gcdB n) ((fun g => g ^ n) g) = g
tactic: dsimp only at key
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key : g ^ ↑((Nat.card G).gcd n) = g ^ (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ (Nat.card G).gcdB n) ((fun g => g ^ n) g) = g
state_after: no goals
tactic: rwa [zpow_add, zpow_mul, zpow_mul, zpow_natCast, zpow_natCast, zpow_natCast, h.gcd_eq_one,
      pow_one, pow_card_eq_one', one_zpow, one_mul, eq_comm] at key
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key :
  (fun x => g ^ x) ↑((Nat.card G).gcd n) =
    (fun x => g ^ x) (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ n) ((fun g => g ^ (Nat.card G).gcdB n) g) = g
state_after: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key : g ^ ↑((Nat.card G).gcd n) = g ^ (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ n) ((fun g => g ^ (Nat.card G).gcdB n) g) = g
tactic: dsimp only at key
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝² : Group G✝
inst✝¹ : Fintype G✝
x : G✝
n : ℕ
G : Type u_6
inst✝ : Group G
h : (Nat.card G).Coprime n
g : G
key : g ^ ↑((Nat.card G).gcd n) = g ^ (↑(Nat.card G) * (Nat.card G).gcdA n + ↑n * (Nat.card G).gcdB n)
⊢ (fun g => g ^ n) ((fun g => g ^ (Nat.card G).gcdB n) g) = g
state_after: no goals
tactic: rwa [zpow_add, zpow_mul, zpow_mul', zpow_natCast, zpow_natCast, zpow_natCast, h.gcd_eq_one,
      pow_one, pow_card_eq_one', one_zpow, one_mul, eq_comm] at key
Theorem: Metric.uniformInducing_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : PseudoMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ), 0 < i' → ∃ i, 0 < i ∧ Prod.map f f ⁻¹' {p | dist p.1 p.2 < i} ⊆ {p | dist p.1 p.2 < i'}) ↔
    ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, dist (f a) (f b) < ε → dist a b < δ
state_after: no goals
tactic: simp only [subset_def, Prod.forall, gt_iff_lt, preimage_setOf_eq, Prod.map_apply, mem_setOf]
Theorem: SetTheory.PGame.Impartial.exists_right_move_equiv_iff_fuzzy_zero
File: Mathlib/SetTheory/Game/Impartial.lean

Proof steps:
state_before: G : PGame
inst✝ : G.Impartial
⊢ (∃ j, G.moveRight j ≈ 0) ↔ G ‖ 0
state_after: G : PGame
inst✝ : G.Impartial
hn : G ‖ 0
⊢ ∃ j, G.moveRight j ≈ 0
tactic: refine ⟨fun ⟨i, hi⟩ => (fuzzy_zero_iff_lf G).2 (lf_of_moveRight_le hi.1), fun hn => ?_⟩
state_before: G : PGame
inst✝ : G.Impartial
hn : G ‖ 0
⊢ ∃ j, G.moveRight j ≈ 0
state_after: G : PGame
inst✝ : G.Impartial
hn : ∃ j, G.moveRight j ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
tactic: rw [fuzzy_zero_iff_lf G, lf_zero_le] at hn
state_before: G : PGame
inst✝ : G.Impartial
hn : ∃ j, G.moveRight j ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
state_after: case intro
G : PGame
inst✝ : G.Impartial
i : G.RightMoves
hi : G.moveRight i ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
tactic: cases' hn with i hi
state_before: case intro
G : PGame
inst✝ : G.Impartial
i : G.RightMoves
hi : G.moveRight i ≤ 0
⊢ ∃ j, G.moveRight j ≈ 0
state_after: no goals
tactic: exact ⟨i, (equiv_zero_iff_le _).2 hi⟩
Theorem: Rat.cast_abs
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q✝ : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
q : ℚ
⊢ ↑|q| = |↑q|
state_after: no goals
tactic: simp [abs_eq_max_neg]
Theorem: harmonic_eq_sum_Icc
File: Mathlib/NumberTheory/Harmonic/Defs.lean

Proof steps:
state_before: n : ℕ
⊢ harmonic n = ∑ i ∈ Finset.Icc 1 n, (↑i)⁻¹
state_after: n : ℕ
⊢ ∑ x ∈ Finset.Ico (0 + 1) (n + 1), (↑x)⁻¹ = ∑ i ∈ Finset.Icc 1 n, (↑i)⁻¹
tactic: rw [harmonic, Finset.range_eq_Ico, Finset.sum_Ico_add' (fun (i : ℕ) ↦ (i : ℚ)⁻¹) 0 n (c := 1)]
state_before: n : ℕ
⊢ ∑ x ∈ Finset.Ico (0 + 1) (n + 1), (↑x)⁻¹ = ∑ i ∈ Finset.Icc 1 n, (↑i)⁻¹
state_after: no goals
tactic: simp only [Nat.add_one, Nat.Ico_succ_right]
Theorem: _private.Mathlib.MeasureTheory.Decomposition.SignedHahn.0.MeasureTheory.SignedMeasure.findExistsOneDivLT_spec
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.ExistsOneDivLT s i (MeasureTheory.SignedMeasure.findExistsOneDivLT s i)
state_after: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.ExistsOneDivLT s i (Nat.find ⋯)
tactic: rw [findExistsOneDivLT, dif_pos hi]
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.ExistsOneDivLT s i (Nat.find ⋯)
state_after: no goals
tactic: convert Nat.find_spec (existsNatOneDivLTMeasure_of_not_negative hi)
Theorem: Matrix.one_div_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
⊢ (1 / A) ^ n = 1 / A ^ n
state_after: no goals
tactic: simp only [one_div, inv_zpow]
Theorem: Finset.some_mem_insertNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Finset α
a : α
⊢ some a ∈ insertNone s ↔ a ∈ s
state_after: no goals
tactic: simp
Theorem: localCohomology.hasColimitDiagram
File: Mathlib/Algebra/Homology/LocalCohomology.lean

Proof steps:
state_before: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
⊢ HasColimit (diagram I i)
state_after: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
this : HasColimitsOfShape Dᵒᵖ AddCommGrpMax
⊢ HasColimit (diagram I i)
tactic: have : HasColimitsOfShape Dᵒᵖ (AddCommGrpMax.{u, v}) := inferInstance
state_before: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
this : HasColimitsOfShape Dᵒᵖ AddCommGrpMax
⊢ HasColimit (diagram I i)
state_after: no goals
tactic: infer_instance