ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PiCountable.dist_le_dist_pi_of_dist_lt
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
ι : Type u_2
inst✝¹ : Encodable ι
F : ι → Type u_3
inst✝ : (i : ι) → MetricSpace (F i)
x y : (i : ι) → F i
i : ι
h : dist x y < (1 / 2) ^ encode i
⊢ dist (x i) (y i) ≤ dist x y
state_after: no goals
tactic: simpa only [not_le.2 h, false_or_iff] using min_le_iff.1 (min_dist_le_dist_pi x y i)
Theorem: ContinuousMultilinearMap.changeOriginSeries_support
File: Mathlib/Analysis/Calculus/FDeriv/Analytic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
k l : ℕ
h : k + l ≠ Fintype.card ι
x✝¹ : { s // s.card = l }
x✝ : x✝¹ ∈ Finset.univ
⊢ f.toFormalMultilinearSeries.changeOriginSeriesTerm k l ↑x✝¹ ⋯ = 0
state_after: no goals
tactic: simp_rw [FormalMultilinearSeries.changeOriginSeriesTerm,
      toFormalMultilinearSeries, dif_neg h.symm, LinearIsometryEquiv.map_zero]
Theorem: List.tfae_not_iff
File: Mathlib/Data/List/TFAE.lean

Proof steps:
state_before: l : List Prop
⊢ (map Not l).TFAE ↔ l.TFAE
state_after: no goals
tactic: classical
  simp only [TFAE, mem_map, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂,
    Decidable.not_iff_not]
Theorem: Topology.IsScott.lowerClosure_subset_closure
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ ↑(lowerClosure s) ⊆ closure s
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ ↑(lowerClosure s) = closure s

case h.e'_4.h.e'_2
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ inst✝¹ = scott α
tactic: convert closure.mono (@upperSet_le_scott α _)
Theorem: ContinuousMultilinearMap.norm_mkPiRing
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
z : G
⊢ ‖ContinuousMultilinearMap.mkPiRing 𝕜 ι z‖ = ‖z‖
state_after: no goals
tactic: rw [ContinuousMultilinearMap.mkPiRing, norm_smulRight, norm_mkPiAlgebra, one_mul]
Theorem: _private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.fastJacobiSym.eq
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: ⊢ jacobiSym = fastJacobiSym
state_after: case h.h
a : ℤ
b : ℕ
⊢ J(a | b) = fastJacobiSym a b
tactic: ext a b
state_before: case h.h
a : ℤ
b : ℕ
⊢ J(a | b) = fastJacobiSym a b
state_after: case h.h.ind
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
⊢ J(a | b) = fastJacobiSym a b
tactic: induction' b using Nat.strongInductionOn with b IH
state_before: case h.h.ind
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
⊢ J(a | b) = fastJacobiSym a b
state_after: case h.h.ind
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
⊢ J(a | b) =
    if hb0 : b = 0 then 1
    else
      if hb2 : b % 2 = 0 then
        if a % 2 = 0 then 0
        else
          let_fun this := ⋯;
          fastJacobiSym a (b / 2)
      else if b = 1 then 1 else if hab : a % ↑b = 0 then 0 else fastJacobiSymAux (a % ↑b).natAbs b false ⋯
tactic: unfold fastJacobiSym
state_before: case h.h.ind
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
⊢ J(a | b) =
    if hb0 : b = 0 then 1
    else
      if hb2 : b % 2 = 0 then
        if a % 2 = 0 then 0
        else
          let_fun this := ⋯;
          fastJacobiSym a (b / 2)
      else if b = 1 then 1 else if hab : a % ↑b = 0 then 0 else fastJacobiSymAux (a % ↑b).natAbs b false ⋯
state_after: case pos
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : b = 0
⊢ J(a | b) = 1

case pos
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : ¬b = 0
hb2 : b % 2 = 0
ha2 : a % 2 = 0
⊢ J(a | b) = 0

case neg
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : ¬b = 0
hb2 : b % 2 = 0
ha2 : ¬a % 2 = 0
⊢ J(a | b) = fastJacobiSym a (b / 2)

case pos
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : ¬b = 0
hb2 : ¬b % 2 = 0
hb1 : b = 1
⊢ J(a | b) = 1

case pos
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : ¬b = 0
hb2 : ¬b % 2 = 0
hb1 : ¬b = 1
hab : a % ↑b = 0
⊢ J(a | b) = 0

case neg
a : ℤ
b : ℕ
IH : ∀ m < b, J(a | m) = fastJacobiSym a m
hb0 : ¬b = 0
hb2 : ¬b % 2 = 0
hb1 : ¬b = 1
hab : ¬a % ↑b = 0
⊢ J(a | b) = fastJacobiSymAux (a % ↑b).natAbs b false ⋯
tactic: split_ifs with hb0 hb2 ha2 hb1 hab
Theorem: Algebra.IsAlgebraic.trans
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Ring A
inst✝³ : Algebra K L
inst✝² : Algebra L A
inst✝¹ : Algebra K A
inst✝ : IsScalarTower K L A
L_alg : Algebra.IsAlgebraic K L
A_alg : Algebra.IsAlgebraic L A
⊢ Algebra.IsAlgebraic K A
state_after: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Ring A
inst✝³ : Algebra K L
inst✝² : Algebra L A
inst✝¹ : Algebra K A
inst✝ : IsScalarTower K L A
L_alg : Algebra.IsIntegral K L
A_alg : Algebra.IsIntegral L A
⊢ Algebra.IsIntegral K A
tactic: rw [Algebra.isAlgebraic_iff_isIntegral] at L_alg A_alg ⊢
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Ring A
inst✝³ : Algebra K L
inst✝² : Algebra L A
inst✝¹ : Algebra K A
inst✝ : IsScalarTower K L A
L_alg : Algebra.IsIntegral K L
A_alg : Algebra.IsIntegral L A
⊢ Algebra.IsIntegral K A
state_after: no goals
tactic: exact Algebra.IsIntegral.trans L
Theorem: PosNum.succ_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ ↑p + 1 + ↑p + 1 = ↑p + ↑p + 1 + 1
state_after: no goals
tactic: simp [add_left_comm]
Theorem: ENNReal.sum_lt_sum_of_nonempty
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
hs : s.Nonempty
f g : α → ℝ≥0∞
Hlt : ∀ i ∈ s, f i < g i
⊢ ∑ i ∈ s, f i < ∑ i ∈ s, g i
state_after: no goals
tactic: induction hs using Finset.Nonempty.cons_induction with
  | singleton => simp [Hlt _ (Finset.mem_singleton_self _)]
  | cons _ _ _ _ ih =>
    simp only [Finset.sum_cons, forall_mem_cons] at Hlt ⊢
    exact ENNReal.add_lt_add Hlt.1 (ih Hlt.2)
Theorem: Antitone.partMap
File: Mathlib/Order/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Preorder α
f : β → γ
g : α → Part β
hg : Antitone g
⊢ Antitone fun x => map f (g x)
state_after: no goals
tactic: simpa only [← bind_some_eq_map] using hg.partBind antitone_const
Theorem: NNReal.inv_le_of_le_mul
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r p : ℝ≥0
h : 1 ≤ r * p
⊢ r⁻¹ ≤ p
state_after: no goals
tactic: by_cases r = 0 <;> simp [*, inv_le]
Theorem: Finset.prod_Ico_add'
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
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c : α
⊢ ∏ x ∈ Ico a b, f (x + c) = ∏ x ∈ Ico (a + c) (b + c), f x
state_after: α : Type u_1
M : Type u_2
inst✝³ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c : α
⊢ ∏ x ∈ Ico a b, f (x + c) = ∏ x ∈ Ico a b, f ((addRightEmbedding c) x)
tactic: rw [← map_add_right_Ico, prod_map]
state_before: α : Type u_1
M : Type u_2
inst✝³ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c : α
⊢ ∏ x ∈ Ico a b, f (x + c) = ∏ x ∈ Ico a b, f ((addRightEmbedding c) x)
state_after: no goals
tactic: rfl
Theorem: zpow_left_injective
File: Mathlib/Algebra/Order/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn : n ≠ 0
⊢ Injective fun x => x ^ n
state_after: case inl
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn✝ : n ≠ 0
hn : n < 0
⊢ Injective fun x => x ^ n

case inr
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedCommGroup α
n : ℤ
a b : α
hn✝ : n ≠ 0
hn : 0 < n
⊢ Injective fun x => x ^ n
tactic: obtain hn | hn := hn.lt_or_lt
Theorem: AlgebraicGeometry.isIso_iff_stalk_iso
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
⊢ IsIso f ↔ IsIso f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (Scheme.Hom.stalkMap f x)
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
⊢ ((Epi f.val.base ∧ OpenEmbedding ⇑f.val.base) ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (Scheme.Hom.stalkMap f x)) ↔
    IsIso f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (Scheme.Hom.stalkMap f x)
tactic: rw [isIso_iff_isOpenImmersion, IsOpenImmersion.iff_stalk_iso, and_comm, ← and_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
⊢ ((Epi f.val.base ∧ OpenEmbedding ⇑f.val.base) ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (Scheme.Hom.stalkMap f x)) ↔
    IsIso f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (Scheme.Hom.stalkMap f x)
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
⊢ Epi f.val.base ∧ OpenEmbedding ⇑f.val.base → IsIso f.val.base

case refine_2
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
⊢ IsIso f.val.base → Epi f.val.base ∧ OpenEmbedding ⇑f.val.base
tactic: refine and_congr ⟨?_, ?_⟩ Iff.rfl
Theorem: Matroid.Restriction.eq_restrict
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
⊢ M ↾ N.E = N
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
⊢ M ↾ (M ↾ R).E = M ↾ R
tactic: obtain ⟨R, -, rfl⟩ := h
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
⊢ M ↾ (M ↾ R).E = M ↾ R
state_after: no goals
tactic: rw [restrict_ground_eq]
Theorem: Comon_.mkIso_inv_hom
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.inv ≫ M.counit = N.counit
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.inv ≫ f.hom ≫ N.counit = N.counit
tactic: rw [← f_counit]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.inv ≫ f.hom ≫ N.counit = N.counit
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.inv ≫ M.comul = N.comul ≫ (f.inv ⊗ f.inv)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.hom ≫ f.inv ≫ M.comul = f.hom ≫ N.comul ≫ (f.inv ⊗ f.inv)
tactic: rw [← cancel_epi f.hom]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.hom ≫ f.inv ≫ M.comul = f.hom ≫ N.comul ≫ (f.inv ⊗ f.inv)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.hom ≫ f.inv ≫ M.comul = (M.comul ≫ (f.hom ⊗ f.hom)) ≫ (f.inv ⊗ f.inv)
tactic: slice_rhs 1 2 => rw [f_comul]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Comon_ C
f : M.X ≅ N.X
f_counit : autoParam (f.hom ≫ N.counit = M.counit) _auto✝
f_comul : autoParam (f.hom ≫ N.comul = M.comul ≫ (f.hom ⊗ f.hom)) _auto✝
⊢ f.hom ≫ f.inv ≫ M.comul = (M.comul ≫ (f.hom ⊗ f.hom)) ≫ (f.inv ⊗ f.inv)
state_after: no goals
tactic: simp
Theorem: Metric.exists_isLocalMin_mem_ball
File: Mathlib/Topology/MetricSpace/ProperSpace/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : ProperSpace α
x : α
r✝ : ℝ
s : Set α
inst✝² : TopologicalSpace β
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a z : α
r : ℝ
hf : ContinuousOn f (closedBall a r)
hz : z ∈ closedBall a r
hf1 : ∀ z' ∈ sphere a r, f z < f z'
⊢ ∃ z ∈ ball a r, IsLocalMin f z
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : ProperSpace α
x : α
r✝ : ℝ
s : Set α
inst✝² : TopologicalSpace β
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a z : α
r : ℝ
hf : ContinuousOn f (closedBall a r)
hz : z ∈ closedBall a r
hf1 : ∀ z' ∈ closedBall a r \ ball a r, f z < f z'
⊢ ∃ z ∈ ball a r, IsLocalMin f z
tactic: simp_rw [← closedBall_diff_ball] at hf1
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : PseudoMetricSpace α
inst✝³ : ProperSpace α
x : α
r✝ : ℝ
s : Set α
inst✝² : TopologicalSpace β
inst✝¹ : ConditionallyCompleteLinearOrder β
inst✝ : OrderTopology β
f : α → β
a z : α
r : ℝ
hf : ContinuousOn f (closedBall a r)
hz : z ∈ closedBall a r
hf1 : ∀ z' ∈ closedBall a r \ ball a r, f z < f z'
⊢ ∃ z ∈ ball a r, IsLocalMin f z
state_after: no goals
tactic: exact (isCompact_closedBall a r).exists_isLocalMin_mem_open ball_subset_closedBall hf hz hf1
    isOpen_ball
Theorem: Turing.Tape.write_self
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (T : Tape Γ), write T.head T = T
state_after: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ write { head := head✝, left := left✝, right := right✝ }.head { head := head✝, left := left✝, right := right✝ } =
    { head := head✝, left := left✝, right := right✝ }
tactic: rintro ⟨⟩
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ write { head := head✝, left := left✝, right := right✝ }.head { head := head✝, left := left✝, right := right✝ } =
    { head := head✝, left := left✝, right := right✝ }
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.kernelIsoOfEq_inv_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
⊢ (kernelIsoOfEq h).inv ≫ kernel.ι f = kernel.ι g
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).inv ≫ kernel.ι f = kernel.ι f
tactic: cases h
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).inv ≫ kernel.ι f = kernel.ι f
state_after: no goals
tactic: simp
Theorem: Finset.eq_univ_iff_forall
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s t : Finset α
⊢ s = univ ↔ ∀ (x : α), x ∈ s
state_after: no goals
tactic: simp [ext_iff]
Theorem: CategoryTheory.zeroMul_hom
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
tactic: have : (prod.snd : A ⨯ I ⟶ I) = CartesianClosed.uncurry (t.to _) := by
      rw [← curry_eq_iff]
      apply t.hom_ext
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ prod.snd ≫ t.to (A ⨯ I) = 𝟙 (A ⨯ I)
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ t.to (A ⟹ I) ≫ (exp A).map (t.to (A ⨯ I)) = curry (𝟙 (A ⨯ I))
tactic: rw [this, ← uncurry_natural_right, ← eq_curry_iff]
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
this : prod.snd = uncurry (t.to (A ⟹ I))
⊢ t.to (A ⟹ I) ≫ (exp A).map (t.to (A ⨯ I)) = curry (𝟙 (A ⨯ I))
state_after: no goals
tactic: apply t.hom_ext
Theorem: MeasureTheory.integrable_stoppedValue_of_mem_finset
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝¹ : PartialOrder ι
ℱ : Filtration ι m
inst✝ : NormedAddCommGroup E
hτ : IsStoppingTime ℱ τ
hu : ∀ (n : ι), Integrable (u n) μ
s : Finset ι
hbdd : ∀ (ω : Ω), τ ω ∈ s
⊢ Integrable (stoppedValue u τ) μ
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝¹ : PartialOrder ι
ℱ : Filtration ι m
inst✝ : NormedAddCommGroup E
hτ : IsStoppingTime ℱ τ
s : Finset ι
hbdd : ∀ (ω : Ω), τ ω ∈ s
hu : ∀ (n : ι), Memℒp (u n) 1 μ
⊢ Memℒp (stoppedValue u τ) 1 μ
tactic: simp_rw [← memℒp_one_iff_integrable] at hu ⊢
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
μ : Measure Ω
τ σ : Ω → ι
E : Type u_4
p : ℝ≥0∞
u : ι → Ω → E
inst✝¹ : PartialOrder ι
ℱ : Filtration ι m
inst✝ : NormedAddCommGroup E
hτ : IsStoppingTime ℱ τ
s : Finset ι
hbdd : ∀ (ω : Ω), τ ω ∈ s
hu : ∀ (n : ι), Memℒp (u n) 1 μ
⊢ Memℒp (stoppedValue u τ) 1 μ
state_after: no goals
tactic: exact memℒp_stoppedValue_of_mem_finset hτ hu hbdd
Theorem: Zspan.map_fundamentalDomain
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

Proof steps:
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
⊢ ⇑f '' fundamentalDomain b = fundamentalDomain (b.map f)
state_after: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ fundamentalDomain (b.map f)
tactic: ext x
state_before: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ fundamentalDomain (b.map f)
state_after: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ ⇑f.toEquiv '' fundamentalDomain b
tactic: rw [mem_fundamentalDomain, Basis.map_repr, LinearEquiv.trans_apply, ← mem_fundamentalDomain,
    show f.symm x = f.toEquiv.symm x by rfl, ← Set.mem_image_equiv]
state_before: case h
E : Type u_1
ι : Type u_2
K : Type u_3
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
F : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace K F
f : E ≃ₗ[K] F
x : F
⊢ x ∈ ⇑f '' fundamentalDomain b ↔ x ∈ ⇑f.toEquiv '' fundamentalDomain b
state_after: no goals
tactic: rfl
Theorem: Multiset.count_pos
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
⊢ 0 < count a s ↔ a ∈ s
state_after: no goals
tactic: simp [count, countP_pos]
Theorem: PNat.mod_coe
File: Mathlib/Data/PNat/Defs.lean

Proof steps:
state_before: m k : ℕ+
⊢ ↑(m.mod k) = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
state_after: m k : ℕ+
⊢ ↑(k.modDivAux (↑m % ↑k) (↑m / ↑k)).1 = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
tactic: dsimp [mod, modDiv]
state_before: m k : ℕ+
⊢ ↑(k.modDivAux (↑m % ↑k) (↑m / ↑k)).1 = if ↑m % ↑k = 0 then ↑k else ↑m % ↑k
state_after: no goals
tactic: cases (m : ℕ) % (k : ℕ) with
  | zero =>
    rw [if_pos rfl]
    rfl
  | succ n =>
    rw [if_neg n.succ_ne_zero]
    rfl
Theorem: Ordinal.nfp_add_zero
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a : Ordinal.{u_1}
⊢ nfp (fun x => a + x) 0 = a * ω
state_after: a : Ordinal.{u_1}
⊢ (sup fun n => (fun x => a + x)^[n] 0) = sup fun n => a * ↑n
tactic: simp_rw [← sup_iterate_eq_nfp, ← sup_mul_nat]
state_before: a : Ordinal.{u_1}
⊢ (sup fun n => (fun x => a + x)^[n] 0) = sup fun n => a * ↑n
state_after: case e_f
a : Ordinal.{u_1}
⊢ (fun n => (fun x => a + x)^[n] 0) = fun n => a * ↑n
tactic: congr
state_before: case e_f
a : Ordinal.{u_1}
⊢ (fun n => (fun x => a + x)^[n] 0) = fun n => a * ↑n
state_after: case e_f.h
a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a + x)^[n] 0 = a * ↑n
tactic: funext n
state_before: case e_f.h
a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a + x)^[n] 0 = a * ↑n
state_after: case e_f.h.zero
a : Ordinal.{u_1}
⊢ (fun x => a + x)^[0] 0 = a * ↑0

case e_f.h.succ
a : Ordinal.{u_1}
n : ℕ
hn : (fun x => a + x)^[n] 0 = a * ↑n
⊢ (fun x => a + x)^[n + 1] 0 = a * ↑(n + 1)
tactic: induction' n with n hn