ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContinuousLinearMap.opNNNorm_le_bound'
File: Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁸ : SeminormedAddCommGroup E
inst✝¹⁷ : SeminormedAddCommGroup Eₗ
inst✝¹⁶ : SeminormedAddCommGroup F
inst✝¹⁵ : SeminormedAddCommGroup Fₗ
inst✝¹⁴ : SeminormedAddCommGroup G
inst✝¹³ : SeminormedAddCommGroup Gₗ
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : NontriviallyNormedField 𝕜₂
inst✝¹⁰ : NontriviallyNormedField 𝕜₃
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : NormedSpace 𝕜 Eₗ
inst✝⁷ : NormedSpace 𝕜₂ F
inst✝⁶ : NormedSpace 𝕜 Fₗ
inst✝⁵ : NormedSpace 𝕜₃ G
inst✝⁴ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : FunLike 𝓕 E F
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
f : E →SL[σ₁₂] F
M : ℝ≥0
hM : ∀ (x : E), ‖x‖₊ ≠ 0 → ‖f x‖₊ ≤ M * ‖x‖₊
x : E
hx : ‖x‖ ≠ 0
⊢ ‖x‖₊ ≠ 0
state_after: no goals
tactic: rwa [← NNReal.coe_ne_zero]
Theorem: Algebra.essFiniteType_iff_exists_subalgebra
File: Mathlib/RingTheory/EssentialFiniteness.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
⊢ EssFiniteType R S ↔ ∃ S₀ M, FiniteType R ↥S₀ ∧ IsLocalization M S
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
⊢ (∃ S₀ M, FiniteType R ↥S₀ ∧ IsLocalization M S) → EssFiniteType R S
tactic: refine ⟨fun h ↦ ⟨subalgebra R S, submonoid R S, inferInstance, inferInstance⟩, ?_⟩
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
⊢ (∃ S₀ M, FiniteType R ↥S₀ ∧ IsLocalization M S) → EssFiniteType R S
state_after: case intro.intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
S₀ : Subalgebra R S
M : Submonoid ↥S₀
left✝ : FiniteType R ↥S₀
right✝ : IsLocalization M S
⊢ EssFiniteType R S
tactic: rintro ⟨S₀, M, _, _⟩
state_before: case intro.intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
S₀ : Subalgebra R S
M : Submonoid ↥S₀
left✝ : FiniteType R ↥S₀
right✝ : IsLocalization M S
⊢ EssFiniteType R S
state_after: case intro.intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
S₀ : Subalgebra R S
M : Submonoid ↥S₀
left✝ : FiniteType R ↥S₀
right✝ : IsLocalization M S
this : EssFiniteType (↥S₀) S := of_isLocalization S M
⊢ EssFiniteType R S
tactic: letI := of_isLocalization S M
state_before: case intro.intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
S₀ : Subalgebra R S
M : Submonoid ↥S₀
left✝ : FiniteType R ↥S₀
right✝ : IsLocalization M S
this : EssFiniteType (↥S₀) S := of_isLocalization S M
⊢ EssFiniteType R S
state_after: no goals
tactic: exact comp R S₀ S
Theorem: Matrix.isHermitian_diagonal_iff
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A : Matrix n n α
inst✝⁴ : AddMonoid α
inst✝³ : StarAddMonoid α
inst✝² : AddMonoid β
inst✝¹ : StarAddMonoid β
inst✝ : DecidableEq n
d : n → α
⊢ (diagonal d).IsHermitian ↔ ∀ (i : n), IsSelfAdjoint (d i)
state_after: no goals
tactic: simp [isSelfAdjoint_iff, IsHermitian, conjTranspose, diagonal_transpose, diagonal_map]
Theorem: IsAddUnit.mem_addSubmonoid_iff
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ submonoid M ↔ IsUnit a
state_after: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ setOf IsUnit ↔ IsUnit a
tactic: change a ∈ setOf IsUnit ↔ IsUnit a
state_before: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ setOf IsUnit ↔ IsUnit a
state_after: no goals
tactic: rw [Set.mem_setOf_eq]
Theorem: Complex.dist_of_re_eq
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
h : z.re = w.re
⊢ dist z w = dist z.im w.im
state_after: no goals
tactic: rw [dist_eq_re_im, h, sub_self, zero_pow two_ne_zero, zero_add, Real.sqrt_sq_eq_abs, Real.dist_eq]
Theorem: Asymptotics.isLittleO_const_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
c : E''
⊢ (fun _x => c) =o[l] g'' ↔ c = 0 ∨ Tendsto (norm ∘ g'') l atTop
state_after: case inl
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (fun _x => 0) =o[l] g'' ↔ 0 = 0 ∨ Tendsto (norm ∘ g'') l atTop

case inr
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
c : E''
hc : c ≠ 0
⊢ (fun _x => c) =o[l] g'' ↔ c = 0 ∨ Tendsto (norm ∘ g'') l atTop
tactic: rcases eq_or_ne c 0 with (rfl | hc)
Theorem: Finset.cons_induction
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α✝
s✝ t u v : Finset α✝
a b : α✝
α : Type u_4
p : Finset α → Prop
empty : p ∅
cons : ∀ (a : α) (s : Finset α) (h : a ∉ s), p s → p (Finset.cons a s h)
s : Multiset α
nd : s.Nodup
⊢ p { val := s, nodup := nd }
state_after: no goals
tactic: induction s using Multiset.induction with
    | empty => exact empty
    | cons a s IH =>
      rw [mk_cons nd]
      exact cons a _ _ (IH _)
Theorem: Nat.binaryRec_eq
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ : ℕ
C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
h : f false 0 z = z
b : Bool
n : ℕ
⊢ binaryRec z f (bit b n) = f b n (binaryRec z f n)
state_after: m n✝ : ℕ
C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
h : f false 0 z = z
b : Bool
n : ℕ
⊢ (if n0 : bit b n = 0 then ⋯.mpr z
    else
      let n' := (bit b n).div2;
      let_fun _x := ⋯;
      ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
tactic: rw [binaryRec]
state_before: m n✝ : ℕ
C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
h : f false 0 z = z
b : Bool
n : ℕ
⊢ (if n0 : bit b n = 0 then ⋯.mpr z
    else
      let n' := (bit b n).div2;
      let_fun _x := ⋯;
      ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
state_after: case pos
m n✝ : ℕ
C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
h : f false 0 z = z
b : Bool
n : ℕ
h' : bit b n = 0
⊢ ⋯.mpr z = f b n (binaryRec z f n)

case neg
m n✝ : ℕ
C : ℕ → Sort u
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
h : f false 0 z = z
b : Bool
n : ℕ
h' : ¬bit b n = 0
⊢ (let n' := (bit b n).div2;
    let_fun _x := ⋯;
    ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
tactic: split_ifs with h'
Theorem: Nat.snd_mem_divisors_of_mem_antidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
x : ℕ × ℕ
h : x ∈ n.divisorsAntidiagonal
⊢ x.2 ∈ n.divisors
state_after: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.2 ∈ n.divisors
tactic: rw [mem_divisorsAntidiagonal] at h
state_before: n : ℕ
x : ℕ × ℕ
h : x.1 * x.2 = n ∧ n ≠ 0
⊢ x.2 ∈ n.divisors
state_after: no goals
tactic: simp [Dvd.intro_left _ h.1, h.2]
Theorem: Matrix.mulVec_injective_iff
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝² : CommSemiring R✝
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
R : Type u_6
inst✝ : CommRing R
M : Matrix m n R
⊢ Function.Injective M.mulVec ↔ LinearIndependent R fun i => Mᵀ i
state_after: R✝ : Type u_1
inst✝² : CommSemiring R✝
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
R : Type u_6
inst✝ : CommRing R
M : Matrix m n R
⊢ (Function.Injective fun x => M *ᵥ x) ↔ LinearIndependent R fun i => Mᵀ i
tactic: change Function.Injective (fun x ↦ _) ↔ _
state_before: R✝ : Type u_1
inst✝² : CommSemiring R✝
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
R : Type u_6
inst✝ : CommRing R
M : Matrix m n R
⊢ (Function.Injective fun x => M *ᵥ x) ↔ LinearIndependent R fun i => Mᵀ i
state_after: no goals
tactic: simp_rw [← M.vecMul_transpose, vecMul_injective_iff]
Theorem: Matrix.BlockTriangular.sub
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b : m → α
inst✝ : LT α
hM : M.BlockTriangular b
hN : N.BlockTriangular b
i j : m
h : b j < b i
⊢ (M - N) i j = 0
state_after: no goals
tactic: simp_rw [Matrix.sub_apply, hM h, hN h, sub_zero]
Theorem: CoxeterSystem.length_eq_one_iff
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w = 1 ↔ ∃ i, w = cs.simple i
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w = 1 → ∃ i, w = cs.simple i

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ (∃ i, w = cs.simple i) → cs.length w = 1
tactic: constructor
Theorem: Matrix.det_of_mem_unitary
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

Proof steps:
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ A : Matrix n n α
hA : A ∈ unitaryGroup n α
⊢ A.det ∈ unitary α
state_after: case left
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ A : Matrix n n α
hA : A ∈ unitaryGroup n α
⊢ star A.det * A.det = 1

case right
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ A : Matrix n n α
hA : A ∈ unitaryGroup n α
⊢ A.det * star A.det = 1
tactic: constructor
Theorem: NumberField.Units.dirichletUnitTheorem.mult_log_place_eq_zero
File: Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ↑w.mult * Real.log (w ((algebraMap (𝓞 K) K) ↑x)) = 0 ↔ w ((algebraMap (𝓞 K) K) ↑x) = 1
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = -1

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = 0

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬↑w.mult = 0
tactic: rw [mul_eq_zero, or_iff_right, Real.log_eq_zero, or_iff_right, or_iff_left]
Theorem: ModularGroup.T_inv_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

Proof steps:
state_before: g : SL(2, ℤ)
⊢ ↑(T⁻¹ * g) 1 = ↑g 1
state_after: no goals
tactic: simpa using T_pow_mul_apply_one (-1) g
Theorem: TruncatedWittVector.zmodEquivTrunc_apply
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
x : ZMod (p ^ n)
⊢ ?m.7315 ∣ p ^ n
state_after: no goals
tactic: rfl
Theorem: Nat.xgcdAux_fst
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: x y : ℕ
⊢ ∀ (n : ℕ) (s t s' t' : ℤ), (xgcdAux 0 s t n s' t').1 = gcd 0 n
state_after: no goals
tactic: simp
state_before: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (x.xgcdAux s t y s' t').1 = x.gcd y
state_after: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (y % x).gcd x = x.gcd y
tactic: simp only [h, xgcdAux_rec, IH]
state_before: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (y % x).gcd x = x.gcd y
state_after: no goals
tactic: rw [← gcd_rec]
Theorem: ContinuousMap.exists_extension
File: Mathlib/Topology/TietzeExtension.lean

Proof steps:
state_before: X₁ : Type u₁
inst✝⁴ : TopologicalSpace X₁
X : Type u
inst✝³ : TopologicalSpace X
inst✝² : NormalSpace X
s : Set X
hs : IsClosed s
e : X₁ → X
he : ClosedEmbedding e
Y : Type v
inst✝¹ : TopologicalSpace Y
inst✝ : TietzeExtension Y
f : C(X₁, Y)
⊢ ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
state_after: X₁ : Type u₁
inst✝⁴ : TopologicalSpace X₁
X : Type u
inst✝³ : TopologicalSpace X
inst✝² : NormalSpace X
s : Set X
hs : IsClosed s
e : X₁ → X
he : ClosedEmbedding e
Y : Type v
inst✝¹ : TopologicalSpace Y
inst✝ : TietzeExtension Y
f : C(X₁, Y)
e' : X₁ ≃ₜ ↑(Set.range e) := Homeomorph.ofEmbedding e ⋯
⊢ ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
tactic: let e' : X₁ ≃ₜ Set.range e := Homeomorph.ofEmbedding _ he.toEmbedding
state_before: X₁ : Type u₁
inst✝⁴ : TopologicalSpace X₁
X : Type u
inst✝³ : TopologicalSpace X
inst✝² : NormalSpace X
s : Set X
hs : IsClosed s
e : X₁ → X
he : ClosedEmbedding e
Y : Type v
inst✝¹ : TopologicalSpace Y
inst✝ : TietzeExtension Y
f : C(X₁, Y)
e' : X₁ ≃ₜ ↑(Set.range e) := Homeomorph.ofEmbedding e ⋯
⊢ ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
state_after: case intro
X₁ : Type u₁
inst✝⁴ : TopologicalSpace X₁
X : Type u
inst✝³ : TopologicalSpace X
inst✝² : NormalSpace X
s : Set X
hs : IsClosed s
e : X₁ → X
he : ClosedEmbedding e
Y : Type v
inst✝¹ : TopologicalSpace Y
inst✝ : TietzeExtension Y
f : C(X₁, Y)
e' : X₁ ≃ₜ ↑(Set.range e) := Homeomorph.ofEmbedding e ⋯
g : C(X, Y)
hg : restrict (Set.range e) g = f.comp e'.symm.toContinuousMap
⊢ ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
tactic: obtain ⟨g, hg⟩ := (f.comp e'.symm).exists_restrict_eq he.isClosed_range
state_before: case intro
X₁ : Type u₁
inst✝⁴ : TopologicalSpace X₁
X : Type u
inst✝³ : TopologicalSpace X
inst✝² : NormalSpace X
s : Set X
hs : IsClosed s
e : X₁ → X
he : ClosedEmbedding e
Y : Type v
inst✝¹ : TopologicalSpace Y
inst✝ : TietzeExtension Y
f : C(X₁, Y)
e' : X₁ ≃ₜ ↑(Set.range e) := Homeomorph.ofEmbedding e ⋯
g : C(X, Y)
hg : restrict (Set.range e) g = f.comp e'.symm.toContinuousMap
⊢ ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
state_after: no goals
tactic: exact ⟨g, by ext x; simpa using congr($(hg) ⟨e' x, x, rfl⟩)⟩
Theorem: UpperSet.compl_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ (⨅ i, ⨅ j, f i j).compl = ⨅ i, ⨅ j, (f i j).compl
state_after: no goals
tactic: simp_rw [UpperSet.compl_iInf]
Theorem: CategoryTheory.Pi.optionEquivalence_counitIso
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝¹ : (i : I) → Category.{v₁, u₁} (C i)
C' : Option J → Type u₁
inst✝ : (i : Option J) → Category.{v₁, u₁} (C' i)
⊢ (Functor.pi' fun i =>
        match i with
        | none => Prod.fst (C' none) ((j : J) → C' (some j))
        | some i => Prod.snd (C' none) ((j : J) → C' (some j)) ⋙ eval (fun j => C' (some j)) i) ⋙
      (eval C' none).prod' (Functor.pi' fun i => eval C' (some i)) ≅
    𝟭 (C' none × ((j : J) → C' (some j)))
state_after: no goals
tactic: exact Iso.refl _
Theorem: Int.toNat_le
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ m.toNat ≤ n ↔ m ≤ ↑n
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ m ≤ ↑n ∧ 0 ≤ ↑n ↔ m ≤ ↑n
tactic: rw [ofNat_le.symm, toNat_eq_max, Int.max_le]
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ m ≤ ↑n ∧ 0 ≤ ↑n ↔ m ≤ ↑n
state_after: no goals
tactic: exact and_iff_left (ofNat_zero_le _)
Theorem: cast_eq_iff_heq
File: .lake/packages/batteries/Batteries/Logic.lean

Proof steps:
state_before: a✝¹ a✝ : Sort u_1
e : a✝¹ = a✝
a : a✝¹
a' : a✝
h : HEq a a'
⊢ cast e a = a'
state_after: case refl
a✝ : Sort u_1
a : a✝
e : a✝ = a✝
⊢ cast e a = a
tactic: cases h
state_before: case refl
a✝ : Sort u_1
a : a✝
e : a✝ = a✝
⊢ cast e a = a
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Bicategory.eqToHom_whiskerRight
File: Mathlib/CategoryTheory/Bicategory/Strict.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f g : a ⟶ b
η : f = g
h : b ⟶ c
⊢ eqToHom η ▷ h = eqToHom ⋯
state_after: case refl
B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
h : b ⟶ c
⊢ eqToHom ⋯ ▷ h = eqToHom ⋯
tactic: cases η
state_before: case refl
B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
h : b ⟶ c
⊢ eqToHom ⋯ ▷ h = eqToHom ⋯
state_after: no goals
tactic: simp only [id_whiskerRight, eqToHom_refl]
Theorem: HurwitzZeta.jacobiTheta₂''_neg_left
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: z τ : ℂ
⊢ jacobiTheta₂'' (-z) τ = -jacobiTheta₂'' z τ
state_after: no goals
tactic: simp only [jacobiTheta₂'', jacobiTheta₂'_neg_left, jacobiTheta₂_neg_left,
    neg_mul, neg_div, ← neg_add, mul_neg, neg_sq]
Theorem: CategoryTheory.Sieve.overEquiv_symm_top
File: Mathlib/CategoryTheory/Sites/Over.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
⊢ (overEquiv Y) ((overEquiv Y).symm ⊤) = (overEquiv Y) ⊤
state_after: no goals
tactic: simp
Theorem: CategoryTheory.essentiallySmall_iff_of_thin
File: Mathlib/CategoryTheory/EssentiallySmall.lean

Proof steps:
state_before: C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Quiver.IsThin C
⊢ EssentiallySmall.{w, v, u} C ↔ Small.{w, u} (Skeleton C)
state_after: no goals
tactic: simp [essentiallySmall_iff, CategoryTheory.locallySmall_of_thin]
Theorem: MeasureTheory.Measure.integral_comp_smul_of_nonneg
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
inst✝³ : FiniteDimensional ℝ E
μ : Measure E
inst✝² : μ.IsAddHaarMeasure
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
f : E → F
R : ℝ
hR : 0 ≤ R
⊢ ∫ (x : E), f (R • x) ∂μ = (R ^ finrank ℝ E)⁻¹ • ∫ (x : E), f x ∂μ
state_after: no goals
tactic: rw [integral_comp_smul μ f R, abs_of_nonneg (inv_nonneg.2 (pow_nonneg hR _))]
Theorem: Ring.eq_mul_inverse_iff_mul_eq
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y z : M₀
h : IsUnit z
h1 : x = y * inverse z
⊢ x * z = y
state_after: no goals
tactic: rw [h1, inverse_mul_cancel_right _ _ h]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y z : M₀
h : IsUnit z
h1 : x * z = y
⊢ x = y * inverse z
state_after: no goals
tactic: rw [← h1, mul_inverse_cancel_right _ _ h]
Theorem: Set.image_const_add_Ico
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ico b c = Ico (a + b) (a + c)
state_after: no goals
tactic: simp only [add_comm a, image_add_const_Ico]
Theorem: tsum_eq_zero_of_not_summable
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : ¬Multipliable f
⊢ ∏' (b : β), f b = 1
state_after: no goals
tactic: simp [tprod_def, h]
Theorem: Set.Finite.absorbs_sInter
File: Mathlib/Topology/Bornology/Absorbs.lean

Proof steps:
state_before: G₀ : Type u_1
α : Type u_2
inst✝² : GroupWithZero G₀
inst✝¹ : Bornology G₀
inst✝ : MulAction G₀ α
s t u : Set α
S : Set (Set α)
hS : S.Finite
⊢ Absorbs G₀ (⋂₀ S) t ↔ ∀ s ∈ S, Absorbs G₀ s t
state_after: no goals
tactic: simp only [absorbs_iff_eventually_cobounded_mapsTo, mapsTo_sInter, hS.eventually_all]
Theorem: Filter.Tendsto.atTop_mul_const_of_neg'
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedRing R
inst✝ : Archimedean R
hr : r < 0
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x * r) l atBot
state_after: no goals
tactic: simpa only [tendsto_neg_atTop_iff, mul_neg] using hf.atTop_mul_const' (neg_pos.mpr hr)