ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieDerivation.lie_ad
File: Mathlib/Algebra/Lie/Derivation/AdjointAction.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x : L
D : LieDerivation R L L
⊢ ⁅(ad R L) x, D⁆ = ⁅x, D⁆
state_after: case H
R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x : L
D : LieDerivation R L L
a✝ : L
⊢ ⁅(ad R L) x, D⁆ a✝ = ⁅x, D⁆ a✝
tactic: ext
state_before: case H
R : Type u_1
L : Type u_2
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x : L
D : LieDerivation R L L
a✝ : L
⊢ ⁅(ad R L) x, D⁆ a✝ = ⁅x, D⁆ a✝
state_after: no goals
tactic: simp
Theorem: Rat.one_mul
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : Rat
⊢ 1 * a = a
state_after: no goals
tactic: simp [mul_def, normalize_self]
Theorem: Ring.inverse_sub_inverse
File: Mathlib/Algebra/Ring/Invertible.lean

Proof steps:
state_before: α : Type u
inst✝ : Ring α
a b : α
h : IsUnit a ↔ IsUnit b
⊢ inverse a - inverse b = inverse a * (b - a) * inverse b
state_after: case pos
α : Type u
inst✝ : Ring α
a b : α
h : IsUnit a ↔ IsUnit b
ha : IsUnit a
⊢ inverse a - inverse b = inverse a * (b - a) * inverse b

case neg
α : Type u
inst✝ : Ring α
a b : α
h : IsUnit a ↔ IsUnit b
ha : ¬IsUnit a
⊢ inverse a - inverse b = inverse a * (b - a) * inverse b
tactic: by_cases ha : IsUnit a
Theorem: ProbabilityTheory.abs_truncation_le_bound
File: Mathlib/Probability/StrongLaw.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |truncation f A x| ≤ |A|
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |A|
tactic: simp only [truncation, Set.indicator, Set.mem_Icc, id, Function.comp_apply]
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
⊢ |if f x ∈ Set.Ioc (-A) A then f x else 0| ≤ |A|
state_after: case pos
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
h : f x ∈ Set.Ioc (-A) A
⊢ |f x| ≤ |A|

case neg
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
x : α
h : f x ∉ Set.Ioc (-A) A
⊢ |0| ≤ |A|
tactic: split_ifs with h
Theorem: SetTheory.PGame.leftMoves_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ (nim o).LeftMoves = (Quotient.out o).α
state_after: o : Ordinal.{u_1}
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).LeftMoves =
    (Quotient.out o).α
tactic: rw [nim_def]
state_before: o : Ordinal.{u_1}
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).LeftMoves =
    (Quotient.out o).α
state_after: no goals
tactic: rfl
Theorem: Polynomial.sum_range_pow_eq_bernoulli_sub
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

Proof steps:
state_before: n p : ℕ
⊢ (↑p + 1) * ∑ k ∈ range n, ↑k ^ p = eval (↑n) (bernoulli p.succ) - _root_.bernoulli p.succ
state_after: n p : ℕ
⊢ ∑ i ∈ range (p + 1), _root_.bernoulli i * ↑((p + 1).choose i) * ↑n ^ (p + 1 - i) =
    ∑ i ∈ range (p.succ + 1), eval (↑n) ((monomial i) (_root_.bernoulli (p.succ - i) * ↑(p.succ.choose i))) -
      _root_.bernoulli p.succ

n p : ℕ
⊢ ↑p + 1 ≠ 0
tactic: rw [sum_range_pow, bernoulli_def, eval_finset_sum, ← sum_div, mul_div_cancel₀ _ _]
Theorem: Cubic.degree_of_b_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
⊢ P.toPoly.degree ≤ 1
state_after: no goals
tactic: simpa only [of_b_eq_zero ha hb] using degree_linear_le
Theorem: Cardinal.ofENat_lt_lift
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: x : Cardinal.{v}
m : ℕ∞
⊢ ↑m < lift.{u, v} x ↔ ↑m < x
state_after: no goals
tactic: rw [← lift_ofENat.{u, v}, lift_lt]
Theorem: AlgebraicGeometry.LocallyRingedSpace.isUnit_res_toΓSpecMapBasicOpen
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ IsUnit ((X.toToΓSpecMapBasicOpen r) r)
state_after: case h.e'_3
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ (X.toToΓSpecMapBasicOpen r) r = (X.presheaf.map (eqToHom ⋯).op) ((X.toRingedSpace.presheaf.map (homOfLE ⋯).op) r)
tactic: convert
    (X.presheaf.map <| (eqToHom <| X.toΓSpecMapBasicOpen_eq r).op).isUnit_map
      (X.toRingedSpace.isUnit_res_basicOpen r)
state_before: case h.e'_3
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ (X.toToΓSpecMapBasicOpen r) r = (X.presheaf.map (eqToHom ⋯).op) ((X.toRingedSpace.presheaf.map (homOfLE ⋯).op) r)
state_after: case h.e'_3
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ (X.toToΓSpecMapBasicOpen r) r = (X.toRingedSpace.presheaf.map ((homOfLE ⋯).op ≫ (eqToHom ⋯).op)) r
tactic: erw [← comp_apply, ← Functor.map_comp]
state_before: case h.e'_3
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ (X.toToΓSpecMapBasicOpen r) r = (X.toRingedSpace.presheaf.map ((homOfLE ⋯).op ≫ (eqToHom ⋯).op)) r
state_after: no goals
tactic: congr
Theorem: Path.Homotopy.symm₂_apply
File: Mathlib/Topology/Homotopy/Path.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
⊢ ∀ (x : ↑I), { toFun := fun x => F (x.1, σ x.2), continuous_toFun := ⋯ }.toFun (0, x) = p.symm.toContinuousMap x
state_after: no goals
tactic: simp [Path.symm]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
⊢ ∀ (x : ↑I), { toFun := fun x => F (x.1, σ x.2), continuous_toFun := ⋯ }.toFun (1, x) = q.symm.toContinuousMap x
state_after: no goals
tactic: simp [Path.symm]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
t x : ↑I
hx : x ∈ {0, 1}
⊢ {
        toFun := fun x =>
          { toFun := fun x => F (x.1, σ x.2), continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun
            (t, x),
        continuous_toFun := ⋯ }
      x =
    p.symm.toContinuousMap x
state_after: case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
t x : ↑I
hx : x = 0
⊢ {
        toFun := fun x =>
          { toFun := fun x => F (x.1, σ x.2), continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun
            (t, x),
        continuous_toFun := ⋯ }
      x =
    p.symm.toContinuousMap x

case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
t x : ↑I
hx : x ∈ {1}
⊢ {
        toFun := fun x =>
          { toFun := fun x => F (x.1, σ x.2), continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun
            (t, x),
        continuous_toFun := ⋯ }
      x =
    p.symm.toContinuousMap x
tactic: cases' hx with hx hx
Theorem: Monoid.CoprodI.NeWord.inv_prod
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
G : ι → Type u_4
inst✝ : (i : ι) → Group (G i)
i j : ι
w : NeWord G i j
⊢ w.inv.prod = w.prod⁻¹
state_after: no goals
tactic: induction w <;> simp [inv, *]
Theorem: hasMellin_add
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : ℝ → E
s : ℂ
hf : MellinConvergent f s
hg : MellinConvergent g s
⊢ MellinConvergent (fun t => f t + g t) s
state_after: no goals
tactic: simpa only [MellinConvergent, smul_add] using hf.add hg
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : ℝ → E
s : ℂ
hf : MellinConvergent f s
hg : MellinConvergent g s
⊢ mellin (fun t => f t + g t) s = mellin f s + mellin g s
state_after: no goals
tactic: simpa only [mellin, smul_add] using integral_add hf hg
Theorem: Behrend.sphere_subset_preimage_metric_sphere
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ ↑(sphere n d k)
⊢ x ∈ (fun x => (WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x)) ⁻¹' Metric.sphere 0 √↑k
state_after: no goals
tactic: rw [Set.mem_preimage, mem_sphere_zero_iff_norm, norm_of_mem_sphere hx]
Theorem: Function.IsPeriodicPt.iterate
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n : ℕ
hf : IsPeriodicPt f n x
m : ℕ
⊢ IsPeriodicPt f^[m] n x
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n : ℕ
hf : IsPeriodicPt f n x
m : ℕ
⊢ IsFixedPt f^[n]^[m] x
tactic: rw [IsPeriodicPt, ← iterate_mul, mul_comm, iterate_mul]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m✝ n : ℕ
hf : IsPeriodicPt f n x
m : ℕ
⊢ IsFixedPt f^[n]^[m] x
state_after: no goals
tactic: exact hf.isFixedPt.iterate m
Theorem: MulActionHom.inverse_eq_inverse'
File: Mathlib/GroupTheory/GroupAction/Hom.lean

Proof steps:
state_before: M' : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
φ : M → N
ψ : N → P
χ : M → P
X : Type u_5
inst✝⁵ : SMul M X
inst✝⁴ : SMul M' X
Y : Type u_6
inst✝³ : SMul N Y
inst✝² : SMul M' Y
Z : Type u_7
inst✝¹ : SMul P Z
φ' : N → M
Y₁ : Type u_8
inst✝ : SMul M Y₁
f : X →ₑ[id] Y₁
g : Y₁ → X
h₁ : Function.LeftInverse g ⇑f
h₂ : Function.RightInverse g ⇑f
⊢ f.inverse g h₁ h₂ = f.inverse' g ⋯ h₁ h₂
state_after: no goals
tactic: rfl
Theorem: CoxeterSystem.isReflection_of_mem_leftInvSeq
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
t : W
ht : t ∈ cs.leftInvSeq ω
⊢ cs.IsReflection t
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
t : W
ht : t ∈ cs.rightInvSeq ω.reverse
⊢ cs.IsReflection t
tactic: simp only [leftInvSeq_eq_reverse_rightInvSeq_reverse, mem_reverse] at ht
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
t : W
ht : t ∈ cs.rightInvSeq ω.reverse
⊢ cs.IsReflection t
state_after: no goals
tactic: exact cs.isReflection_of_mem_rightInvSeq ω.reverse ht
Theorem: CategoryTheory.Arrow.cechConerve_obj
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePushout f.left (fun x => f.right) fun x => f.hom
x y : SimplexCategory
g : x ⟶ y
⊢ (fun n => widePushout f.left (fun x => f.right) fun x => f.hom) x ⟶
    (fun n => widePushout f.left (fun x => f.right) fun x => f.hom) y
state_after: C : Type u
inst✝¹ : Category.{v, u} C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePushout f.left (fun x => f.right) fun x => f.hom
x y : SimplexCategory
g : x ⟶ y
j : Fin (x.len + 1)
⊢ f.hom ≫ (fun i => WidePushout.ι (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g) i)) j =
    WidePushout.head fun x => f.hom
tactic: refine WidePushout.desc (WidePushout.head _)
      (fun i => (@WidePushout.ι _ _ _ _ _ (fun _ => f.hom) (_) (g.toOrderHom i))) (fun j => ?_)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePushout f.left (fun x => f.right) fun x => f.hom
x y : SimplexCategory
g : x ⟶ y
j : Fin (x.len + 1)
⊢ f.hom ≫ (fun i => WidePushout.ι (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g) i)) j =
    WidePushout.head fun x => f.hom
state_after: no goals
tactic: erw [← WidePushout.arrow_ι]
Theorem: CategoryTheory.isoClosure_le_iff
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
P Q : C → Prop
inst✝ : ClosedUnderIsomorphisms Q
h : P ≤ Q
⊢ isoClosure Q ≤ Q
state_after: no goals
tactic: rw [isoClosure_eq_self]
Theorem: Finsupp.erase_eq_sub_single
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a : α
⊢ erase a f = f - single a (f a)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a a' : α
⊢ (erase a f) a' = (f - single a (f a)) a'
tactic: ext a'
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a a' : α
⊢ (erase a f) a' = (f - single a (f a)) a'
state_after: case h.inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a : α
⊢ (erase a f) a = (f - single a (f a)) a

case h.inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddGroup G
f : α →₀ G
a a' : α
h : a ≠ a'
⊢ (erase a f) a' = (f - single a (f a)) a'
tactic: rcases eq_or_ne a a' with (rfl | h)
Theorem: mem_perfectClosure_iff_pow_mem
File: Mathlib/FieldTheory/PurelyInseparable.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 : ℕ
inst✝ : ExpChar F q
x : E
⊢ x ∈ perfectClosure F E ↔ ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
state_after: no goals
tactic: rw [mem_perfectClosure_iff, ringExpChar.eq F q]
Theorem: CategoryTheory.MonoidalCategory.id_whiskerLeft_symm
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y Z X X' : C
f : X ⟶ X'
⊢ f = (λ_ X).inv ≫ 𝟙_ C ◁ f ≫ (λ_ X').hom
state_after: no goals
tactic: simp only [id_whiskerLeft, assoc, inv_hom_id, comp_id, inv_hom_id_assoc]
Theorem: MeasureTheory.Submartingale.sub_supermartingale
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
hg : Supermartingale g ℱ μ
⊢ Submartingale (f - g) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
hg : Supermartingale g ℱ μ
⊢ Submartingale (f + -g) ℱ μ
tactic: rw [sub_eq_add_neg]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Submartingale f ℱ μ
hg : Supermartingale g ℱ μ
⊢ Submartingale (f + -g) ℱ μ
state_after: no goals
tactic: exact hf.add hg.neg
Theorem: UniformSpace.comap_iInf
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α✝ : Type ua
β : Type ub
γ✝ : Type uc
δ : Type ud
ι✝ : Sort u_1
ι : Sort u_2
α : Type u_3
γ : Type u_4
u : ι → UniformSpace γ
f : α → γ
⊢ comap f (⨅ i, u i) = ⨅ i, comap f (u i)
state_after: case h
α✝ : Type ua
β : Type ub
γ✝ : Type uc
δ : Type ud
ι✝ : Sort u_1
ι : Sort u_2
α : Type u_3
γ : Type u_4
u : ι → UniformSpace γ
f : α → γ
⊢ 𝓤 α = 𝓤 α
tactic: ext : 1
state_before: case h
α✝ : Type ua
β : Type ub
γ✝ : Type uc
δ : Type ud
ι✝ : Sort u_1
ι : Sort u_2
α : Type u_3
γ : Type u_4
u : ι → UniformSpace γ
f : α → γ
⊢ 𝓤 α = 𝓤 α
state_after: no goals
tactic: simp [uniformity_comap, iInf_uniformity]
Theorem: CategoryTheory.MorphismProperty.LeftFraction₂.map_eq_iff
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.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
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
φ ψ : W.LeftFraction₂ X Y
⊢ φ.fst.map L ⋯ = ψ.fst.map L ⋯ ∧ φ.snd.map L ⋯ = ψ.snd.map L ⋯ ↔ LeftFraction₂Rel φ ψ
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
φ ψ : W.LeftFraction₂ X Y
⊢ LeftFractionRel φ.fst ψ.fst ∧ LeftFractionRel φ.snd ψ.snd ↔ LeftFraction₂Rel φ ψ
tactic: simp only [LeftFraction.map_eq_iff L W]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
φ ψ : W.LeftFraction₂ X Y
⊢ LeftFractionRel φ.fst ψ.fst ∧ LeftFractionRel φ.snd ψ.snd ↔ LeftFraction₂Rel φ ψ
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
φ ψ : W.LeftFraction₂ X Y
⊢ LeftFractionRel φ.fst ψ.fst ∧ LeftFractionRel φ.snd ψ.snd → LeftFraction₂Rel φ ψ

case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
φ ψ : W.LeftFraction₂ X Y
⊢ LeftFraction₂Rel φ ψ → LeftFractionRel φ.fst ψ.fst ∧ LeftFractionRel φ.snd ψ.snd
tactic: constructor
Theorem: CategoryTheory.congrArg_cast_hom_left
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y Z : C
p : X = Y
q : Y ⟶ Z
⊢ cast ⋯ q = eqToHom p ≫ q
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Z : C
q : X ⟶ Z
⊢ cast ⋯ q = eqToHom ⋯ ≫ q
tactic: cases p
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Z : C
q : X ⟶ Z
⊢ cast ⋯ q = eqToHom ⋯ ≫ q
state_after: no goals
tactic: simp
Theorem: List.mem_attach
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
h : a ∈ l
⊢ ⟨a, h⟩ ∈ l.attach
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
h : a ∈ l
this : ∃ a_1, a_1 ∈ l.attach ∧ ↑a_1 = a
⊢ ⟨a, h⟩ ∈ l.attach
tactic: have := mem_map.1 (by rw [attach_map_val] <;> exact h)
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
h : a ∈ l
this : ∃ a_1, a_1 ∈ l.attach ∧ ↑a_1 = a
⊢ ⟨a, h⟩ ∈ l.attach
state_after: case intro.mk.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
val✝ : α
property✝ : val✝ ∈ l
m : ⟨val✝, property✝⟩ ∈ l.attach
h : ↑⟨val✝, property✝⟩ ∈ l
⊢ ⟨↑⟨val✝, property✝⟩, h⟩ ∈ l.attach
tactic: rcases this with ⟨⟨_, _⟩, m, rfl⟩
state_before: case intro.mk.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
val✝ : α
property✝ : val✝ ∈ l
m : ⟨val✝, property✝⟩ ∈ l.attach
h : ↑⟨val✝, property✝⟩ ∈ l
⊢ ⟨↑⟨val✝, property✝⟩, h⟩ ∈ l.attach
state_after: no goals
tactic: exact m
Theorem: AnalyticAt.eventually_eq_zero_or_eventually_ne_zero
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ 0
state_after: case intro
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p✝ q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
p : FormalMultilinearSeries 𝕜 𝕜 E
hp : HasFPowerSeriesAt f p z₀
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ 0
tactic: rcases hf with ⟨p, hp⟩
state_before: case intro
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p✝ q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
p : FormalMultilinearSeries 𝕜 𝕜 E
hp : HasFPowerSeriesAt f p z₀
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ 0
state_after: case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p✝ q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
p : FormalMultilinearSeries 𝕜 𝕜 E
hp : HasFPowerSeriesAt f p z₀
h : p = 0
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ 0

case neg
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p✝ q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
p : FormalMultilinearSeries 𝕜 𝕜 E
hp : HasFPowerSeriesAt f p z₀
h : ¬p = 0
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ 0
tactic: by_cases h : p = 0
Theorem: ProbabilityTheory.geometricPMFReal_pos
File: Mathlib/Probability/Distributions/Geometric.lean

Proof steps:
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < geometricPMFReal p n
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < (1 - p) ^ n * p
tactic: rw [geometricPMFReal]
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
⊢ 0 < (1 - p) ^ n * p
state_after: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
this : 0 < 1 - p
⊢ 0 < (1 - p) ^ n * p
tactic: have : 0 < 1 - p := sub_pos.mpr hp_lt_one
state_before: p : ℝ
n : ℕ
hp_pos : 0 < p
hp_lt_one : p < 1
this : 0 < 1 - p
⊢ 0 < (1 - p) ^ n * p
state_after: no goals
tactic: positivity
Theorem: MvPolynomial.vars_eq_support_biUnion_support
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : CommSemiring S
f : R →+* S
inst✝ : DecidableEq σ
⊢ p.vars = p.support.biUnion Finsupp.support
state_after: case a
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : CommSemiring S
f : R →+* S
inst✝ : DecidableEq σ
i : σ
⊢ i ∈ p.vars ↔ i ∈ p.support.biUnion Finsupp.support
tactic: ext i
state_before: case a
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : CommSemiring S
f : R →+* S
inst✝ : DecidableEq σ
i : σ
⊢ i ∈ p.vars ↔ i ∈ p.support.biUnion Finsupp.support
state_after: no goals
tactic: rw [mem_vars, Finset.mem_biUnion]
Theorem: IsHilbertSum.linearIsometryEquiv_symm_apply_dfinsupp_sum_single
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
hV : IsHilbertSum 𝕜 G V
W₀ : Π₀ (i : ι), G i
⊢ hV.linearIsometryEquiv.symm (W₀.sum (lp.single 2)) = W₀.sum fun i => ⇑(V i)
state_after: no goals
tactic: simp only [map_dfinsupp_sum, IsHilbertSum.linearIsometryEquiv_symm_apply_single]