ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.Kernel.rnDeriv_def'
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
⊢ κ.rnDeriv η = fun a x => ENNReal.ofReal (κ.rnDerivAux (κ + η) a x) / ENNReal.ofReal (1 - κ.rnDerivAux (κ + η) a x)
state_after: case h.h
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
x✝¹ : α
x✝ : γ
⊢ κ.rnDeriv η x✝¹ x✝ = ENNReal.ofReal (κ.rnDerivAux (κ + η) x✝¹ x✝) / ENNReal.ofReal (1 - κ.rnDerivAux (κ + η) x✝¹ x✝)
tactic: ext
state_before: case h.h
α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
x✝¹ : α
x✝ : γ
⊢ κ.rnDeriv η x✝¹ x✝ = ENNReal.ofReal (κ.rnDerivAux (κ + η) x✝¹ x✝) / ENNReal.ofReal (1 - κ.rnDerivAux (κ + η) x✝¹ x✝)
state_after: no goals
tactic: rw [rnDeriv_def]
Theorem: ENNReal.div_eq_top
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / b = ⊤ ↔ a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤
state_after: no goals
tactic: simp [div_eq_mul_inv, ENNReal.mul_eq_top]
Theorem: Equiv.Perm.closure_isCycle
File: Mathlib/GroupTheory/Perm/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Finite β
⊢ closure {σ | σ.IsCycle} = ⊤
state_after: no goals
tactic: classical
    cases nonempty_fintype β
    exact
      top_le_iff.mp (le_trans (ge_of_eq closure_isSwap) (closure_mono fun _ => IsSwap.isCycle))
Theorem: Set.inter_insert_of_mem
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
h : a ∈ s
⊢ s ∩ insert a t = insert a (s ∩ t)
state_after: no goals
tactic: rw [insert_inter_distrib, insert_eq_of_mem h]
Theorem: Equiv.Perm.set_support_mul_subset
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
p q : Perm α
⊢ {x | (p * q) x ≠ x} ⊆ {x | p x ≠ x} ∪ {x | q x ≠ x}
state_after: α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | (p * q) x ≠ x} → x ∈ {x | p x ≠ x} ∪ {x | q x ≠ x}
tactic: intro x
state_before: α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | (p * q) x ≠ x} → x ∈ {x | p x ≠ x} ∪ {x | q x ≠ x}
state_after: α : Type u_1
p q : Perm α
x : α
⊢ ¬p (q x) = x → ¬p x = x ∨ ¬q x = x
tactic: simp only [Perm.coe_mul, Function.comp_apply, Ne, Set.mem_union, Set.mem_setOf_eq]
state_before: α : Type u_1
p q : Perm α
x : α
⊢ ¬p (q x) = x → ¬p x = x ∨ ¬q x = x
state_after: no goals
tactic: by_cases hq : q x = x <;> simp [hq]
Theorem: MultilinearMap.map_zero
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin n.succ) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝ : Nonempty ι
⊢ f 0 = 0
state_after: case intro
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin n.succ) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝ : Nonempty ι
i : ι
h✝ : i ∈ univ
⊢ f 0 = 0
tactic: obtain ⟨i, _⟩ : ∃ i : ι, i ∈ Set.univ := Set.exists_mem_of_nonempty ι
state_before: case intro
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin n.succ) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝ : Nonempty ι
i : ι
h✝ : i ∈ univ
⊢ f 0 = 0
state_after: no goals
tactic: exact map_coord_zero f i rfl
Theorem: Complex.lim_im
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqIm f).lim = f.lim.im
state_after: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqIm f).lim = (↑(cauSeqRe f).lim + ↑(cauSeqIm f).lim * I).im
tactic: rw [lim_eq_lim_im_add_lim_re]
state_before: f : CauSeq ℂ ⇑abs'
⊢ (cauSeqIm f).lim = (↑(cauSeqRe f).lim + ↑(cauSeqIm f).lim * I).im
state_after: no goals
tactic: simp [ofReal']
Theorem: UniqueAdd.of_card_nonpos
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hA : A.Nonempty
hB : B.Nonempty
hA1 : A.card ≤ 1
hB1 : B.card ≤ 1
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hA : A.Nonempty
hB : B.Nonempty
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
tactic: rw [Finset.card_le_one_iff] at hA1 hB1
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hA : A.Nonempty
hB : B.Nonempty
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
state_after: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hB : B.Nonempty
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
a : G
ha : a ∈ A
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
tactic: obtain ⟨a, ha⟩ := hA
state_before: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hB : B.Nonempty
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
a : G
ha : a ∈ A
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
state_after: case intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
a : G
ha : a ∈ A
b : G
hb : b ∈ B
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
tactic: obtain ⟨b, hb⟩ := hB
state_before: case intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
hA1 : ∀ {a b : G}, a ∈ A → b ∈ A → a = b
hB1 : ∀ {a b : G}, a ∈ B → b ∈ B → a = b
a : G
ha : a ∈ A
b : G
hb : b ∈ B
⊢ ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b
state_after: no goals
tactic: exact ⟨a, ha, b, hb, fun _ _ ha' hb' _ ↦ ⟨hA1 ha' ha, hB1 hb' hb⟩⟩
Theorem: Wbtw.dist_le_max_dist
File: Mathlib/Analysis/Convex/StrictConvexBetween.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
state_after: case pos
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : p₂ = p₁
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)

case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
tactic: by_cases hp₁ : p₂ = p₁
state_before: case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
state_after: case pos
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
hp₃ : p₂ = p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)

case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
hp₃ : ¬p₂ = p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
tactic: by_cases hp₃ : p₂ = p₃
state_before: case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
hp₃ : ¬p₂ = p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
state_after: case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
hp₃ : ¬p₂ = p₃
hs : Sbtw ℝ p₁ p₂ p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
tactic: have hs : Sbtw ℝ p₁ p₂ p₃ := ⟨h, hp₁, hp₃⟩
state_before: case neg
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor V P
p p₁ p₂ p₃ : P
h : Wbtw ℝ p₁ p₂ p₃
hp₁ : ¬p₂ = p₁
hp₃ : ¬p₂ = p₃
hs : Sbtw ℝ p₁ p₂ p₃
⊢ dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
state_after: no goals
tactic: exact (hs.dist_lt_max_dist _).le
Theorem: CategoryTheory.ShortComplex.SnakeInput.w₁₃_τ₃
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.v₁₂.τ₃ ≫ S.v₂₃.τ₃ = 0
state_after: no goals
tactic: rw [← comp_τ₃, S.w₁₃, zero_τ₃]
Theorem: Path.Homotopy.transAssocReparamAux_one
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transAssocReparamAux 1 = 1
state_after: no goals
tactic: norm_num [transAssocReparamAux]
Theorem: hasStrictFDerivAt_multiset_prod
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁷ : NormedAddCommGroup G'
inst✝⁶ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g'✝ e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
𝔸 : Type u_7
𝔸' : Type u_8
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedCommRing 𝔸'
inst✝³ : NormedAlgebra 𝕜 𝔸
inst✝² : NormedAlgebra 𝕜 𝔸'
u✝ : Finset ι
f : ι → E → 𝔸
f' : ι → E →L[𝕜] 𝔸
g : ι → E → 𝔸'
g' : ι → E →L[𝕜] 𝔸'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
u : Multiset ι
x : ι → 𝔸'
l : List ι
⊢ HasStrictFDerivAt (fun x => (Multiset.map x ⟦l⟧).prod)
    (Multiset.map (fun i => (Multiset.map x (Multiset.erase ⟦l⟧ i)).prod • proj i) ⟦l⟧).sum x
state_after: no goals
tactic: simpa using hasStrictFDerivAt_list_prod
Theorem: Finset.isUnit_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s t : Finset α
⊢ IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s t : Finset α
⊢ IsUnit s → ∃ a, s = {a} ∧ IsUnit a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s t : Finset α
⊢ (∃ a, s = {a} ∧ IsUnit a) → IsUnit s
tactic: constructor
Theorem: CategoryTheory.Limits.coconeOfDiagramTerminal_ι_app
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u
inst✝ : Category.{v, u} J
X : J
tX : IsTerminal X
F : J ⥤ C
j j' : J
k : j ⟶ j'
⊢ F.map k ≫ (fun j => F.map (tX.from j)) j' = (fun j => F.map (tX.from j)) j ≫ ((Functor.const J).obj (F.obj X)).map k
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u
inst✝ : Category.{v, u} J
X : J
tX : IsTerminal X
F : J ⥤ C
j j' : J
k : j ⟶ j'
⊢ F.map k ≫ F.map (tX.from j') = F.map (tX.from j) ≫ 𝟙 (F.obj X)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u
inst✝ : Category.{v, u} J
X : J
tX : IsTerminal X
F : J ⥤ C
j j' : J
k : j ⟶ j'
⊢ F.map k ≫ F.map (tX.from j') = F.map (tX.from j) ≫ 𝟙 (F.obj X)
state_after: no goals
tactic: rw [← F.map_comp, Category.comp_id, tX.hom_ext (k ≫ tX.from j') (tX.from j)]
Theorem: Multiset.toFinsupp_sum_eq
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s : Multiset α
⊢ ((toFinsupp s).sum fun x => id) = card s
state_after: no goals
tactic: rw [← Finsupp.card_toMultiset, toFinsupp_toMultiset]
Theorem: mapClusterPt_iff
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
x : X
F : Filter ι
u : ι → X
⊢ MapClusterPt x F u ↔ ∀ s ∈ 𝓝 x, ∃ᶠ (a : ι) in F, u a ∈ s
state_after: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
x : X
F : Filter ι
u : ι → X
⊢ (∀ {p : X → Prop}, (∀ᶠ (x : X) in 𝓝 x, p x) → ∃ᶠ (a : ι) in F, p (u a)) ↔ ∀ s ∈ 𝓝 x, ∃ᶠ (a : ι) in F, u a ∈ s
tactic: simp_rw [MapClusterPt, ClusterPt, inf_neBot_iff_frequently_left, frequently_map]
state_before: X : Type u
Y : Type v
ι✝ : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
ι : Type u_3
x : X
F : Filter ι
u : ι → X
⊢ (∀ {p : X → Prop}, (∀ᶠ (x : X) in 𝓝 x, p x) → ∃ᶠ (a : ι) in F, p (u a)) ↔ ∀ s ∈ 𝓝 x, ∃ᶠ (a : ι) in F, u a ∈ s
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.snd (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j) =
    pullback.snd ((𝒰.pullbackCover s.fst).map i) ((𝒰.pullbackCover s.fst).map j) ≫ pullback.snd s.fst (𝒰.map j)
state_after: no goals
tactic: simp [gluedLiftPullbackMap]
Theorem: Polynomial.cyclotomic_pos_and_nonneg
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝ : LinearOrderedCommRing R
x : R
⊢ (1 < x → 0 < eval x (cyclotomic n R)) ∧ (1 ≤ x → 0 ≤ eval x (cyclotomic n R))
state_after: case zero
R : Type u_1
inst✝ : LinearOrderedCommRing R
x : R
⊢ (1 < x → 0 < eval x (cyclotomic 0 R)) ∧ (1 ≤ x → 0 ≤ eval x (cyclotomic 0 R))

case succ.zero
R : Type u_1
inst✝ : LinearOrderedCommRing R
x : R
⊢ (1 < x → 0 < eval x (cyclotomic (0 + 1) R)) ∧ (1 ≤ x → 0 ≤ eval x (cyclotomic (0 + 1) R))

case succ.succ.zero
R : Type u_1
inst✝ : LinearOrderedCommRing R
x : R
⊢ (1 < x → 0 < eval x (cyclotomic (0 + 1 + 1) R)) ∧ (1 ≤ x → 0 ≤ eval x (cyclotomic (0 + 1 + 1) R))

case succ.succ.succ
R : Type u_1
inst✝ : LinearOrderedCommRing R
x : R
n : ℕ
⊢ (1 < x → 0 < eval x (cyclotomic (n + 1 + 1 + 1) R)) ∧ (1 ≤ x → 0 ≤ eval x (cyclotomic (n + 1 + 1 + 1) R))
tactic: rcases n with (_ | _ | _ | n)
Theorem: UniformConcaveOn.add
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hg : UniformConcaveOn s ψ g
⊢ UniformConcaveOn s (φ + ψ) (f + g)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hg : UniformConcaveOn s ψ g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (f + g) x + b • (f + g) y + a * b * (φ + ψ) ‖x - y‖ ≤ (f + g) (a • x + b • y)
tactic: refine ⟨hf.1, fun x hx y hy a b ha hb hab ↦ ?_⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hg : UniformConcaveOn s ψ g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (f + g) x + b • (f + g) y + a * b * (φ + ψ) ‖x - y‖ ≤ (f + g) (a • x + b • y)
state_after: no goals
tactic: simpa [mul_add, add_add_add_comm] using add_le_add (hf.2 hx hy ha hb hab) (hg.2 hx hy ha hb hab)
Theorem: MeasureTheory.condexpIndL1_of_not_measurableSet
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜 F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : CompleteSpace F'
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace ℝ G'
inst✝² : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝¹ : NormedSpace ℝ G
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : ¬MeasurableSet s
x : G
⊢ condexpIndL1 hm μ s x = 0
state_after: no goals
tactic: simp only [condexpIndL1, hs, dif_neg, not_false_iff, false_and_iff]
Theorem: AList.insert_singleton_eq
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
⊢ (insert a b (singleton a b')).entries = (singleton a b).entries
state_after: no goals
tactic: simp only [AList.insert_entries, List.kerase_cons_eq, and_self_iff, AList.singleton_entries,
      heq_iff_eq, eq_self_iff_true]
Theorem: Complex.arg_nonneg_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im
state_after: case inl
a x z : ℂ
⊢ 0 ≤ arg 0 ↔ 0 ≤ im 0

case inr
a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im
tactic: rcases eq_or_ne z 0 with (rfl | h₀)
state_before: case inr
a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im
state_after: no goals
tactic: calc
    0 ≤ arg z ↔ 0 ≤ Real.sin (arg z) :=
      ⟨fun h => Real.sin_nonneg_of_mem_Icc ⟨h, arg_le_pi z⟩, by
        contrapose!
        intro h
        exact Real.sin_neg_of_neg_of_neg_pi_lt h (neg_pi_lt_arg _)⟩
    _ ↔ _ := by rw [sin_arg, le_div_iff (abs.pos h₀), zero_mul]
Theorem: List.length_sigma
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
σ : α → Type u_8
l₁ : List α
l₂ : (a : α) → List (σ a)
⊢ (l₁.sigma l₂).length = (map (fun a => (l₂ a).length) l₁).sum
state_after: no goals
tactic: simp [length_sigma']
Theorem: CategoryTheory.ProjectiveResolution.iso_hom_naturality
File: Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasProjectiveResolutions C
X Y : C
f : X ⟶ Y
P : ProjectiveResolution X
Q : ProjectiveResolution Y
φ : P.complex ⟶ Q.complex
comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f
⊢ (projectiveResolutions C).map f ≫ Q.iso.hom = P.iso.hom ≫ (HomotopyCategory.quotient C (ComplexShape.down ℕ)).map φ
state_after: no goals
tactic: rw [← cancel_epi (P.iso).inv, iso_inv_naturality_assoc f P Q φ comm,
    Iso.inv_hom_id_assoc, Iso.inv_hom_id, comp_id]
Theorem: GenContFract.convs'_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
n_le_m : n ≤ m
terminatedAt_n : g.TerminatedAt n
⊢ g.convs' m = g.convs' n
state_after: no goals
tactic: simp only [convs', convs'Aux_stable_of_terminated n_le_m terminatedAt_n]
Theorem: CochainComplex.mappingConeCompTriangle_obj₃
File: Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.342, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
⊢ f ≫ g = 𝟙 X₁ ≫ f ≫ g
state_after: no goals
tactic: rw [id_comp]
state_before: C : Type u_1
inst✝³ : Category.{?u.342, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
⊢ (f ≫ g) ≫ 𝟙 X₃ = f ≫ g
state_after: no goals
tactic: rw [comp_id]
Theorem: NNReal.coe_lt_one
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑r < 1 ↔ r < 1
state_after: no goals
tactic: rw [← coe_lt_coe, coe_one]
Theorem: conj_zpow
File: Mathlib/Algebra/Group/Conj.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Group α
i : ℤ
a b : α
⊢ (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹
state_after: case ofNat
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ (a * b * a⁻¹) ^ Int.ofNat a✝ = a * b ^ Int.ofNat a✝ * a⁻¹

case negSucc
α : Type u
β : Type v
inst✝ : Group α
a b : α
a✝ : ℕ
⊢ (a * b * a⁻¹) ^ Int.negSucc a✝ = a * b ^ Int.negSucc a✝ * a⁻¹
tactic: induction' i
Theorem: Finset.univ_of_card_le_two
File: Mathlib/RingTheory/Fintype.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Ring R
inst✝¹ : Fintype R
inst✝ : DecidableEq R
h : Fintype.card R ≤ 2
⊢ univ = {0, 1}
state_after: case inl
R : Type u_1
inst✝² : Ring R
inst✝¹ : Fintype R
inst✝ : DecidableEq R
h : Fintype.card R ≤ 2
h✝ : Subsingleton R
⊢ univ = {0, 1}

case inr
R : Type u_1
inst✝² : Ring R
inst✝¹ : Fintype R
inst✝ : DecidableEq R
h : Fintype.card R ≤ 2
h✝ : Nontrivial R
⊢ univ = {0, 1}
tactic: rcases subsingleton_or_nontrivial R
Theorem: Prefunctor.symmetrifyStar
File: Mathlib/Combinatorics/Quiver/Covering.lean

Proof steps:
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.4270
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ φ.symmetrify.star u =
    ⇑(Quiver.symmetrifyStar (φ.obj u)).symm ∘ Sum.map (φ.star u) (φ.costar u) ∘ ⇑(Quiver.symmetrifyStar u)
state_after: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.4270
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ ⇑(Quiver.symmetrifyStar (φ.obj u)) ∘ φ.symmetrify.star u =
    Sum.map (φ.star u) (φ.costar u) ∘ ⇑(Quiver.symmetrifyStar u)
tactic: erw [Equiv.eq_symm_comp]
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.4270
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ ⇑(Quiver.symmetrifyStar (φ.obj u)) ∘ φ.symmetrify.star u =
    Sum.map (φ.star u) (φ.costar u) ∘ ⇑(Quiver.symmetrifyStar u)
state_after: no goals
tactic: ext ⟨v, f | g⟩ <;>
    -- porting note (#10745): was `simp [Quiver.symmetrifyStar]`
    simp only [Quiver.symmetrifyStar, Function.comp_apply] <;>
    erw [Equiv.sigmaSumDistrib_apply, Equiv.sigmaSumDistrib_apply] <;>
    simp
Theorem: SignType.neg_eq_self_iff
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: a : SignType
⊢ -a = a ↔ a = 0
state_after: no goals
tactic: cases a <;> decide
Theorem: Matrix.transvection_zero
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
i j : n
⊢ transvection i j 0 = 1
state_after: no goals
tactic: simp [transvection]