ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: mem_closure_iff_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ x ∈ closure s ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ (∀ i ∈ 𝓝 1, ∃ y ∈ s, y ∈ {y | y / x ∈ id i}) ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U
tactic: rw [mem_closure_iff_nhds_basis ((𝓝 1 : Filter G).basis_sets.nhds_of_one x)]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ (∀ i ∈ 𝓝 1, ∃ y ∈ s, y ∈ {y | y / x ∈ id i}) ↔ ∀ U ∈ 𝓝 1, ∃ y ∈ s, y / x ∈ U
state_after: no goals
tactic: simp_rw [Set.mem_setOf, id]
Theorem: Finpartition.part_mem
File: Mathlib/Order/Partition/Finpartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
ha : a ∈ s
⊢ P.part a ∈ P.parts
state_after: no goals
tactic: simp [part, ha, choose_mem]
Theorem: Finset.sum_range_sub_sum_range
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ (∏ k ∈ range m, f k) / ∏ k ∈ range n, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
state_after: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∏ k ∈ Ico n m, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
tactic: rw [← prod_Ico_eq_div f hnm]
state_before: α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∏ k ∈ Ico n m, f k = ∏ k ∈ filter (fun k => n ≤ k) (range m), f k
state_after: case e_s
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ Ico n m = filter (fun k => n ≤ k) (range m)
tactic: congr
state_before: case e_s
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ Ico n m = filter (fun k => n ≤ k) (range m)
state_after: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), a ∈ Ico n m ↔ a ∈ filter (fun k => n ≤ k) (range m)
tactic: apply Finset.ext
state_before: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), a ∈ Ico n m ↔ a ∈ filter (fun k => n ≤ k) (range m)
state_after: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), n ≤ a ∧ a < m ↔ a < m ∧ n ≤ a
tactic: simp only [mem_Ico, mem_filter, mem_range, *]
state_before: case e_s.a
α✝ : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α✝
a : α✝
g f✝ : α✝ → M
α : Type u_3
inst✝ : CommGroup α
f : ℕ → α
n m : ℕ
hnm : n ≤ m
⊢ ∀ (a : ℕ), n ≤ a ∧ a < m ↔ a < m ∧ n ≤ a
state_after: no goals
tactic: tauto
Theorem: mul_nonpos_iff
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Ring α
inst✝⁴ : LinearOrder α
a b : α
inst✝³ : MulPosStrictMono α
inst✝² : PosMulStrictMono α
inst✝¹ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a * b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b
state_after: no goals
tactic: rw [← neg_nonneg, neg_mul_eq_mul_neg, mul_nonneg_iff (α := α), neg_nonneg, neg_nonpos]
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_of_not_adj
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

Proof steps:
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - μ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
tactic: rw [← h.of_not_adj hne ha]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: no goals
tactic: apply h.card_neighborFinset_union_eq
Theorem: Quiver.Hom.cast_eq_iff_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

Proof steps:
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ cast hu hv e = e' ↔ HEq e e'
state_after: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ _root_.cast ⋯ e = e' ↔ HEq e e'
tactic: rw [Hom.cast_eq_cast]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ _root_.cast ⋯ e = e' ↔ HEq e e'
state_after: no goals
tactic: exact _root_.cast_eq_iff_heq
Theorem: CategoryTheory.Adjunction.rightAdjointUniq_hom_app_counit
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ F.map ((adj1.rightAdjointUniq adj2).hom.app x) ≫ adj2.counit.app x = adj1.counit.app x
state_after: no goals
tactic: simp [rightAdjointUniq]
Theorem: Matroid.Basis.basis_restriction
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
hI : M.Basis I X
hNM : N ≤r M
hX : X ⊆ N.E
⊢ N.Basis I X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hI : M.Basis I X
R : Set α
hR : R ⊆ M.E
hX : X ⊆ (M ↾ R).E
⊢ (M ↾ R).Basis I X
tactic: obtain ⟨R, hR, rfl⟩ := hNM
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y : Set α
hI : M.Basis I X
R : Set α
hR : R ⊆ M.E
hX : X ⊆ (M ↾ R).E
⊢ (M ↾ R).Basis I X
state_after: no goals
tactic: rwa [basis_restrict_iff, and_iff_left (show X ⊆ R from hX)]
Theorem: NumberField.mixedEmbedding.convexBodySum_compact
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ IsCompact (convexBodySum K B)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ IsClosed (convexBodySum K B) ∧ Bornology.IsBounded (convexBodySum K B)
tactic: rw [Metric.isCompact_iff_isClosed_bounded]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ IsClosed (convexBodySum K B) ∧ Bornology.IsBounded (convexBodySum K B)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ IsClosed (convexBodySum K B)
tactic: refine ⟨?_, convexBodySum_isBounded K B⟩
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ IsClosed (convexBodySum K B)
state_after: case h.e'_3
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ convexBodySum K B = convexBodySumFun ⁻¹' Set.Icc 0 B
tactic: convert IsClosed.preimage (convexBodySumFun_continuous K) (isClosed_Icc : IsClosed (Set.Icc 0 B))
state_before: case h.e'_3
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ convexBodySum K B = convexBodySumFun ⁻¹' Set.Icc 0 B
state_after: case h.e'_3.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x✝ : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ x✝ ∈ convexBodySum K B ↔ x✝ ∈ convexBodySumFun ⁻¹' Set.Icc 0 B
tactic: ext
state_before: case h.e'_3.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x✝ : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
⊢ x✝ ∈ convexBodySum K B ↔ x✝ ∈ convexBodySumFun ⁻¹' Set.Icc 0 B
state_after: no goals
tactic: simp [convexBodySumFun_nonneg]
Theorem: Equiv.Set.univPi_apply_coe
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
x✝ : ↑(univ.pi s)
f : (i : α) → β i
hf : f ∈ univ.pi s
⊢ (fun f => ⟨fun a => ↑(f a), ⋯⟩) ((fun f a => ⟨↑f a, ⋯⟩) ⟨f, hf⟩) = ⟨f, hf⟩
state_after: case a.h
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
x✝ : ↑(univ.pi s)
f : (i : α) → β i
hf : f ∈ univ.pi s
a : α
⊢ ↑((fun f => ⟨fun a => ↑(f a), ⋯⟩) ((fun f a => ⟨↑f a, ⋯⟩) ⟨f, hf⟩)) a = ↑⟨f, hf⟩ a
tactic: ext a
state_before: case a.h
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
x✝ : ↑(univ.pi s)
f : (i : α) → β i
hf : f ∈ univ.pi s
a : α
⊢ ↑((fun f => ⟨fun a => ↑(f a), ⋯⟩) ((fun f a => ⟨↑f a, ⋯⟩) ⟨f, hf⟩)) a = ↑⟨f, hf⟩ a
state_after: no goals
tactic: rfl
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
f : (a : α) → ↑(s a)
⊢ (fun f a => ⟨↑f a, ⋯⟩) ((fun f => ⟨fun a => ↑(f a), ⋯⟩) f) = f
state_after: case h.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
f : (a : α) → ↑(s a)
a : α
⊢ ↑((fun f a => ⟨↑f a, ⋯⟩) ((fun f => ⟨fun a => ↑(f a), ⋯⟩) f) a) = ↑(f a)
tactic: ext a
state_before: case h.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : α → Type u_2
s : (a : α) → Set (β a)
f : (a : α) → ↑(s a)
a : α
⊢ ↑((fun f a => ⟨↑f a, ⋯⟩) ((fun f => ⟨fun a => ↑(f a), ⋯⟩) f) a) = ↑(f a)
state_after: no goals
tactic: rfl
Theorem: Set.Ico_union_Ico'
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
⊢ Ico a b ∪ Ico c d = Ico (min a c) (max b d)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ x ∈ Ico a b ∪ Ico c d ↔ x ∈ Ico (min a c) (max b d)
tactic: ext1 x
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ x ∈ Ico a b ∪ Ico c d ↔ x ∈ Ico (min a c) (max b d)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)
tactic: simp_rw [mem_union, mem_Ico, min_le_iff, lt_max_iff]
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : ¬x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

case pos
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c ≤ x
hd : x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c ≤ x
hd : ¬x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)
tactic: by_cases hc : c ≤ x <;> by_cases hd : x < d
Theorem: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_ε
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X Y Z : Cᴹᵒᵖ
⊢ (fun X Y => (β_ X.unmop Y.unmop).hom) X Y ▷ __spread✝⁻⁰.obj Z ≫
      (fun X Y => (β_ X.unmop Y.unmop).hom) (X ⊗ Y) Z ≫ __spread✝⁻⁰.map (α_ X Y Z).hom =
    (α_ (__spread✝⁻⁰.obj X) (__spread✝⁻⁰.obj Y) (__spread✝⁻⁰.obj Z)).hom ≫
      __spread✝⁻⁰.obj X ◁ (fun X Y => (β_ X.unmop Y.unmop).hom) Y Z ≫ (fun X Y => (β_ X.unmop Y.unmop).hom) X (Y ⊗ Z)
state_after: no goals
tactic: simp [← yang_baxter_assoc]
Theorem: seminormFromBounded_of_mul_le
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : ∀ (y : R), f (x * y) ≤ f x * f y
h_one : f 1 ≤ 1
⊢ seminormFromBounded' f x = f x
state_after: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : ∀ (y : R), f (x * y) ≤ f x * f y
h_one : f 1 ≤ 1
⊢ ⨆ y, f (x * y) / f y = f x
tactic: simp_rw [seminormFromBounded']
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : ∀ (y : R), f (x * y) ≤ f x * f y
h_one : f 1 ≤ 1
⊢ ⨆ y, f (x * y) / f y = f x
state_after: case a
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : ∀ (y : R), f (x * y) ≤ f x * f y
h_one : f 1 ≤ 1
⊢ ⨆ y, f (x * y) / f y ≤ f x

case a
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
x : R
hx : ∀ (y : R), f (x * y) ≤ f x * f y
h_one : f 1 ≤ 1
⊢ f x ≤ ⨆ y, f (x * y) / f y
tactic: apply le_antisymm
Theorem: Finset.none_mem_insertNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Finset α
⊢ none ∈ insertNone s
state_after: no goals
tactic: simp
Theorem: inf_sdiff_eq_bot_iff
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ z ⊓ y \ x = ⊥ ↔ z ≤ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ Disjoint z (y \ x) ↔ z ≤ x
tactic: rw [← disjoint_iff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ Disjoint z (y \ x) ↔ z ≤ x
state_after: no goals
tactic: exact disjoint_sdiff_iff_le hz hx
Theorem: ContDiffAt.differentiableAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
hn : 1 ≤ n
⊢ DifferentiableAt 𝕜 f x
state_after: no goals
tactic: simpa [hn, differentiableWithinAt_univ] using h.differentiableWithinAt
Theorem: MeasureTheory.stoppedValue_stoppedValue_leastGE
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f✝ : ℕ → Ω → ℝ
ω : Ω
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
⊢ stoppedValue (fun i => stoppedValue f (leastGE f r i)) π = stoppedValue (stoppedProcess f (leastGE f r n)) π
state_after: case h
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f✝ : ℕ → Ω → ℝ
ω✝ : Ω
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
ω : Ω
⊢ stoppedValue (fun i => stoppedValue f (leastGE f r i)) π ω = stoppedValue (stoppedProcess f (leastGE f r n)) π ω
tactic: ext1 ω
state_before: case h
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f✝ : ℕ → Ω → ℝ
ω✝ : Ω
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
ω : Ω
⊢ stoppedValue (fun i => stoppedValue f (leastGE f r i)) π ω = stoppedValue (stoppedProcess f (leastGE f r n)) π ω
state_after: case h
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f✝ : ℕ → Ω → ℝ
ω✝ : Ω
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
ω : Ω
⊢ f (leastGE f r (π ω) ω) ω = f (min (π ω) (leastGE f r n ω)) ω
tactic: simp (config := { unfoldPartialApp := true }) only [stoppedProcess, stoppedValue]
state_before: case h
Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f✝ : ℕ → Ω → ℝ
ω✝ : Ω
f : ℕ → Ω → ℝ
π : Ω → ℕ
r : ℝ
n : ℕ
hπn : ∀ (ω : Ω), π ω ≤ n
ω : Ω
⊢ f (leastGE f r (π ω) ω) ω = f (min (π ω) (leastGE f r n ω)) ω
state_after: no goals
tactic: rw [leastGE_eq_min _ _ _ hπn]
Theorem: CompositionSeries.jordan_holder
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
⊢ s₁.Equivalent s₂
state_after: case zero
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hle : s₁.length = 0
⊢ s₁.Equivalent s₂

case succ
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
n : ℕ
ih : ∀ (s₁ s₂ : CompositionSeries X), head s₁ = head s₂ → last s₁ = last s₂ → s₁.length = n → s₁.Equivalent s₂
s₁ s₂ : CompositionSeries X
hb : head s₁ = head s₂
ht : last s₁ = last s₂
hle : s₁.length = n + 1
⊢ s₁.Equivalent s₂
tactic: induction' hle : s₁.length with n ih generalizing s₁ s₂
Theorem: Polynomial.dvd_iterate_derivative_pow
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
f : R[X]
n m : ℕ
c : R
hm : m ≠ 0
⊢ ↑n ∣ eval c ((⇑derivative)^[m] (f ^ n))
state_after: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
f : R[X]
n : ℕ
c : R
m : ℕ
hm : m.succ ≠ 0
⊢ ↑n ∣ eval c ((⇑derivative)^[m.succ] (f ^ n))
tactic: obtain ⟨m, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hm
state_before: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
f : R[X]
n : ℕ
c : R
m : ℕ
hm : m.succ ≠ 0
⊢ ↑n ∣ eval c ((⇑derivative)^[m.succ] (f ^ n))
state_after: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
f : R[X]
n : ℕ
c : R
m : ℕ
hm : m.succ ≠ 0
⊢ ↑n ∣ ↑n * eval c ((⇑derivative)^[m] (f ^ (n - 1) * derivative f))
tactic: rw [Function.iterate_succ_apply, derivative_pow, mul_assoc, C_eq_natCast,
    iterate_derivative_natCast_mul, eval_mul, eval_natCast]
state_before: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
f : R[X]
n : ℕ
c : R
m : ℕ
hm : m.succ ≠ 0
⊢ ↑n ∣ ↑n * eval c ((⇑derivative)^[m] (f ^ (n - 1) * derivative f))
state_after: no goals
tactic: exact dvd_mul_right _ _
Theorem: Int.units_pow_eq_pow_mod_two
File: Mathlib/Data/Int/Order/Units.lean

Proof steps:
state_before: u : ℤˣ
n : ℕ
⊢ u ^ n = u ^ (n % 2)
state_after: no goals
tactic: conv =>
    lhs
    rw [← Nat.mod_add_div n 2]
    rw [pow_add, pow_mul, units_sq, one_pow, mul_one]
Theorem: ONote.mulNat_eq_mul
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: n : ℕ
o : ONote
⊢ o.mulNat n = o * ↑n
state_after: no goals
tactic: cases o <;> cases n <;> rfl
Theorem: Set.toFinset_Ico
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ico a b)
⊢ (Ico a b).toFinset = Finset.Ico a b
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ico a b)
a✝ : α
⊢ a✝ ∈ (Ico a b).toFinset ↔ a✝ ∈ Finset.Ico a b
tactic: ext
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ico a b)
a✝ : α
⊢ a✝ ∈ (Ico a b).toFinset ↔ a✝ ∈ Finset.Ico a b
state_after: no goals
tactic: simp
Theorem: Cardinal.lift_le_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: x : Cardinal.{v}
m : ℕ∞
⊢ lift.{u, v} x ≤ ↑m ↔ x ≤ ↑m
state_after: no goals
tactic: rw [← lift_ofENat.{u, v}, lift_le]
Theorem: Set.image_sub_const_Ioi
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Ioi b = Ioi (b - a)
state_after: no goals
tactic: simp [sub_eq_neg_add]
Theorem: Complex.neg_pi_lt_log_im
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℂ
⊢ -π < (log x).im
state_after: no goals
tactic: simp only [log_im, neg_pi_lt_arg]
Theorem: MeasureTheory.stoppedValue_lowerCrossingTime
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : lowerCrossingTime a b f N n ω ≠ N
⊢ stoppedValue f (lowerCrossingTime a b f N n) ω ≤ a
state_after: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : lowerCrossingTime a b f N n ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (upperCrossingTime a b f N n ω) (lowerCrossingTime a b f N n ω)
hj₂ : f j ω ∈ Set.Iic a
⊢ stoppedValue f (lowerCrossingTime a b f N n) ω ≤ a
tactic: obtain ⟨j, hj₁, hj₂⟩ := (hitting_le_iff_of_lt _ (lt_of_le_of_ne lowerCrossingTime_le h)).1 le_rfl
state_before: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : lowerCrossingTime a b f N n ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (upperCrossingTime a b f N n ω) (lowerCrossingTime a b f N n ω)
hj₂ : f j ω ∈ Set.Iic a
⊢ stoppedValue f (lowerCrossingTime a b f N n) ω ≤ a
state_after: no goals
tactic: exact stoppedValue_hitting_mem ⟨j, ⟨hj₁.1, le_trans hj₁.2 lowerCrossingTime_le⟩, hj₂⟩