ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.Primrec'.sqrt
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: ⊢ ∀ (n : ℕ), n.sqrt = Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n
state_after: n : ℕ
⊢ n.sqrt = Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n
tactic: introv
state_before: n : ℕ
⊢ n.sqrt = Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n
state_after: n : ℕ
⊢ Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
tactic: symm
state_before: n : ℕ
⊢ Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
state_after: case zero

⊢ Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) 0 = Nat.sqrt 0

case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) (n + 1) = (n + 1).sqrt
tactic: induction' n with n IH
state_before: case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) (n + 1) = (n + 1).sqrt
state_after: case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ (if
        n + 1 <
          (Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) *
            (Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) then
      Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n
    else Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) =
    (n + 1).sqrt
tactic: dsimp
state_before: case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ (if
        n + 1 <
          (Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) *
            (Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) then
      Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n
    else Nat.rec 0 (fun x y => if x + 1 < (y + 1) * (y + 1) then y else y + 1) n + 1) =
    (n + 1).sqrt
state_after: case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ (if n + 1 < (n.sqrt + 1) * (n.sqrt + 1) then n.sqrt else n.sqrt + 1) = (n + 1).sqrt
tactic: rw [IH]
state_before: case succ
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
⊢ (if n + 1 < (n.sqrt + 1) * (n.sqrt + 1) then n.sqrt else n.sqrt + 1) = (n + 1).sqrt
state_after: case pos
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
h : n + 1 < (n.sqrt + 1) * (n.sqrt + 1)
⊢ n.sqrt = (n + 1).sqrt

case neg
n : ℕ
IH : Nat.rec 0 (fun x y => if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt
h : ¬n + 1 < (n.sqrt + 1) * (n.sqrt + 1)
⊢ n.sqrt + 1 = (n + 1).sqrt
tactic: split_ifs with h
Theorem: Real.rpow_le_rpow_of_exponent_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ x ^ y ≤ x ^ z
state_after: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)
tactic: repeat' rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)
state_after: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ log x * y ≤ log x * z
tactic: rw [exp_le_exp]
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ log x * y ≤ log x * z
state_after: no goals
tactic: exact mul_le_mul_of_nonneg_left hyz (log_nonneg hx)
Theorem: CauSeq.mul_equiv_zero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this : (f - 0).LimZero
⊢ f.LimZero
state_after: no goals
tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this✝ : (f - 0).LimZero
this : (g * f).LimZero
⊢ (g * f - 0).LimZero
state_after: no goals
tactic: simpa
Theorem: Real.measurable_of_measurable_exp
File: Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean

Proof steps:
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
hf : Measurable fun x => rexp (f x)
⊢ Measurable f
state_after: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
hf : Measurable fun x => rexp (f x)
this : f = fun x => log (rexp (f x))
⊢ Measurable f
tactic: have : f = fun x ↦ log (exp (f x)) := by ext; rw [log_exp]
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
hf : Measurable fun x => rexp (f x)
this : f = fun x => log (rexp (f x))
⊢ Measurable f
state_after: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
hf : Measurable fun x => rexp (f x)
this : f = fun x => log (rexp (f x))
⊢ Measurable fun x => log (rexp (f x))
tactic: rw [this]
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
hf : Measurable fun x => rexp (f x)
this : f = fun x => log (rexp (f x))
⊢ Measurable fun x => log (rexp (f x))
state_after: no goals
tactic: exact measurable_log.comp hf
Theorem: intrinsicClosure_diff_intrinsicFrontier
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s✝ t : Set P
x : P
s : Set P
⊢ (fun a => ↑a) '' (closure (Subtype.val ⁻¹' s) \ frontier (Subtype.val ⁻¹' s)) = intrinsicInterior 𝕜 s
state_after: no goals
tactic: rw [closure_diff_frontier, intrinsicInterior]
Theorem: SimpleGraph.Walk.IsPath.length_lt
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w : V
inst✝ : Fintype V
u v : V
p : G.Walk u v
hp : p.IsPath
⊢ p.length < Fintype.card V
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w : V
inst✝ : Fintype V
u v : V
p : G.Walk u v
hp : p.IsPath
⊢ p.support.length ≤ Fintype.card V
tactic: rw [Nat.lt_iff_add_one_le, ← length_support]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w : V
inst✝ : Fintype V
u v : V
p : G.Walk u v
hp : p.IsPath
⊢ p.support.length ≤ Fintype.card V
state_after: no goals
tactic: exact hp.support_nodup.length_le_card
Theorem: IntervalIntegrable.refl
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b c d : ℝ
μ ν : Measure ℝ
⊢ IntervalIntegrable f μ a a
state_after: no goals
tactic: constructor <;> simp
Theorem: Polynomial.leadingCoeff_X_pow
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
⊢ (X ^ n).leadingCoeff = 1
state_after: no goals
tactic: simpa only [C_1, one_mul] using leadingCoeff_C_mul_X_pow (1 : R) n
Theorem: Asymptotics.IsTheta.div
File: Mathlib/Analysis/Asymptotics/Theta.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
R : Type u_12
R' : Type u_13
𝕜 : Type u_14
𝕜' : Type u_15
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✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
f₁ f₂ : α → 𝕜
g₁ g₂ : α → 𝕜'
h₁ : f₁ =Θ[l] g₁
h₂ : f₂ =Θ[l] g₂
⊢ (fun x => f₁ x / f₂ x) =Θ[l] fun x => g₁ x / g₂ x
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using h₁.mul h₂.inv
Theorem: uniformContinuous_sInf_rng
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
⊢ UniformContinuous f ↔ ∀ u ∈ u₂, UniformContinuous f
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
⊢ Tendsto (fun x => (f x.1, f x.2)) (𝓤 α) (𝓤 β) ↔ ∀ u ∈ u₂, Tendsto (fun x => (f x.1, f x.2)) (𝓤 α) (𝓤 β)
tactic: delta UniformContinuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
⊢ Tendsto (fun x => (f x.1, f x.2)) (𝓤 α) (𝓤 β) ↔ ∀ u ∈ u₂, Tendsto (fun x => (f x.1, f x.2)) (𝓤 α) (𝓤 β)
state_after: no goals
tactic: rw [sInf_eq_iInf', iInf_uniformity, tendsto_iInf, SetCoe.forall]
Theorem: String.extract_cons_addChar
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: c : Char
cs : List Char
b e : Pos
⊢ { data := c :: cs }.extract (b + c) (e + c) = { data := cs }.extract b e
state_after: c : Char
cs : List Char
b e : Pos
⊢ (if e.byteIdx ≤ b.byteIdx then "" else { data := extract.go₁ (c :: cs) 0 (b + c) (e + c) }) =
    if e.byteIdx ≤ b.byteIdx then "" else { data := extract.go₁ cs 0 b e }
tactic: simp only [extract, pos_add_char, ge_iff_le, Nat.add_le_add_iff_right]
state_before: c : Char
cs : List Char
b e : Pos
⊢ (if e.byteIdx ≤ b.byteIdx then "" else { data := extract.go₁ (c :: cs) 0 (b + c) (e + c) }) =
    if e.byteIdx ≤ b.byteIdx then "" else { data := extract.go₁ cs 0 b e }
state_after: no goals
tactic: split <;> [rfl; rw [extract.go₁_cons_addChar]]
Theorem: LieSubmodule.mem_sup
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ x ∈ N ⊔ N' ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ (∃ y ∈ ↑N, ∃ z ∈ ↑N', y + z = x) ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x
tactic: rw [← mem_coeSubmodule, sup_coe_toSubmodule, Submodule.mem_sup]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ (∃ y ∈ ↑N, ∃ z ∈ ↑N', y + z = x) ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x
state_after: no goals
tactic: exact Iff.rfl
Theorem: WeierstrassCurve.Affine.Point.map_baseChange
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝²⁷ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝²⁶ : CommRing R
W : Affine R
S : Type s
inst✝²⁵ : CommRing S
inst✝²⁴ : Algebra R S
A : Type u
inst✝²³ : CommRing A
inst✝²² : Algebra R A
inst✝²¹ : Algebra S A
inst✝²⁰ : IsScalarTower R S A
B : Type v
inst✝¹⁹ : CommRing B
inst✝¹⁸ : Algebra R B
inst✝¹⁷ : Algebra S B
inst✝¹⁶ : IsScalarTower R S B
f✝¹ : A →ₐ[S] B
F : Type u
inst✝¹⁵ : Field F
inst✝¹⁴ : Algebra R F
inst✝¹³ : Algebra S F
inst✝¹² : IsScalarTower R S F
K : Type v
inst✝¹¹ : Field K
inst✝¹⁰ : Algebra R K
inst✝⁹ : Algebra S K
inst✝⁸ : IsScalarTower R S K
f✝ : F →ₐ[S] K
L : Type w
inst✝⁷ : Field L
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra S L
inst✝⁴ : IsScalarTower R S L
g : K →ₐ[S] L
inst✝³ : Algebra F K
inst✝² : IsScalarTower R F K
inst✝¹ : Algebra F L
inst✝ : IsScalarTower R F L
f : K →ₐ[F] L
P : W⟮F⟯
⊢ (map W f) ((baseChange W F K) P) = (baseChange W F L) P
state_after: R✝ : Type u
inst✝²⁷ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝²⁶ : CommRing R
W : Affine R
S : Type s
inst✝²⁵ : CommRing S
inst✝²⁴ : Algebra R S
A : Type u
inst✝²³ : CommRing A
inst✝²² : Algebra R A
inst✝²¹ : Algebra S A
inst✝²⁰ : IsScalarTower R S A
B : Type v
inst✝¹⁹ : CommRing B
inst✝¹⁸ : Algebra R B
inst✝¹⁷ : Algebra S B
inst✝¹⁶ : IsScalarTower R S B
f✝¹ : A →ₐ[S] B
F : Type u
inst✝¹⁵ : Field F
inst✝¹⁴ : Algebra R F
inst✝¹³ : Algebra S F
inst✝¹² : IsScalarTower R S F
K : Type v
inst✝¹¹ : Field K
inst✝¹⁰ : Algebra R K
inst✝⁹ : Algebra S K
inst✝⁸ : IsScalarTower R S K
f✝ : F →ₐ[S] K
L : Type w
inst✝⁷ : Field L
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra S L
inst✝⁴ : IsScalarTower R S L
g : K →ₐ[S] L
inst✝³ : Algebra F K
inst✝² : IsScalarTower R F K
inst✝¹ : Algebra F L
inst✝ : IsScalarTower R F L
f : K →ₐ[F] L
P : W⟮F⟯
this : Subsingleton (F →ₐ[F] L)
⊢ (map W f) ((baseChange W F K) P) = (baseChange W F L) P
tactic: have : Subsingleton (F →ₐ[F] L) := inferInstance
state_before: R✝ : Type u
inst✝²⁷ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝²⁶ : CommRing R
W : Affine R
S : Type s
inst✝²⁵ : CommRing S
inst✝²⁴ : Algebra R S
A : Type u
inst✝²³ : CommRing A
inst✝²² : Algebra R A
inst✝²¹ : Algebra S A
inst✝²⁰ : IsScalarTower R S A
B : Type v
inst✝¹⁹ : CommRing B
inst✝¹⁸ : Algebra R B
inst✝¹⁷ : Algebra S B
inst✝¹⁶ : IsScalarTower R S B
f✝¹ : A →ₐ[S] B
F : Type u
inst✝¹⁵ : Field F
inst✝¹⁴ : Algebra R F
inst✝¹³ : Algebra S F
inst✝¹² : IsScalarTower R S F
K : Type v
inst✝¹¹ : Field K
inst✝¹⁰ : Algebra R K
inst✝⁹ : Algebra S K
inst✝⁸ : IsScalarTower R S K
f✝ : F →ₐ[S] K
L : Type w
inst✝⁷ : Field L
inst✝⁶ : Algebra R L
inst✝⁵ : Algebra S L
inst✝⁴ : IsScalarTower R S L
g : K →ₐ[S] L
inst✝³ : Algebra F K
inst✝² : IsScalarTower R F K
inst✝¹ : Algebra F L
inst✝ : IsScalarTower R F L
f : K →ₐ[F] L
P : W⟮F⟯
this : Subsingleton (F →ₐ[F] L)
⊢ (map W f) ((baseChange W F K) P) = (baseChange W F L) P
state_after: no goals
tactic: convert map_map W (Algebra.ofId F K) f P
Theorem: FreeAddGroup.map_eq_lift
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y : FreeGroup α
x : α
⊢ (lift (of ∘ f)) (of x) = of (f x)
state_after: no goals
tactic: simp
Theorem: circle.ofConjDivSelf_coe
File: Mathlib/Analysis/Complex/Circle.lean

Proof steps:
state_before: z : ℂ
hz : z ≠ 0
⊢ Complex.abs ((starRingEnd ℂ) z / z) = 1
state_after: z : ℂ
hz : z ≠ 0
⊢ Complex.abs z ≠ 0
tactic: rw [map_div₀, abs_conj, div_self]
state_before: z : ℂ
hz : z ≠ 0
⊢ Complex.abs z ≠ 0
state_after: no goals
tactic: exact Complex.abs.ne_zero hz
Theorem: lineMap_lt_lineMap_iff_of_lt
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
h : r < r'
⊢ (lineMap a b) r < (lineMap a b) r' ↔ a < b
state_after: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
h : r < r'
⊢ (1 - r) • a + r • b < (1 - r') • a + r' • b ↔ a < b
tactic: simp only [lineMap_apply_module]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
h : r < r'
⊢ (1 - r) • a + r • b < (1 - r') • a + r' • b ↔ a < b
state_after: no goals
tactic: rw [← lt_sub_iff_add_lt, add_sub_assoc, ← sub_lt_iff_lt_add', ← sub_smul, ← sub_smul,
    sub_sub_sub_cancel_left, smul_lt_smul_iff_of_pos_left (sub_pos.2 h)]
Theorem: DirichletCharacter.convolution_mul_moebius
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: n : ℕ
χ : DirichletCharacter ℂ n
this : (1 ⍟ fun x => ↑(μ x)) = δ
⊢ (fun n_1 => χ ↑n_1) ⍟ ((fun n_1 => χ ↑n_1) * fun n => ↑(μ n)) = δ
state_after: n : ℕ
χ : DirichletCharacter ℂ n
this : (1 ⍟ fun x => ↑(μ x)) = δ
⊢ (fun n_1 => χ ↑n_1) * 1 ⍟ ((fun n_1 => χ ↑n_1) * fun n => ↑(μ n)) = δ
tactic: nth_rewrite 1 [← mul_one ↗χ]
state_before: n : ℕ
χ : DirichletCharacter ℂ n
this : (1 ⍟ fun x => ↑(μ x)) = δ
⊢ (fun n_1 => χ ↑n_1) * 1 ⍟ ((fun n_1 => χ ↑n_1) * fun n => ↑(μ n)) = δ
state_after: no goals
tactic: simpa only [mul_convolution_distrib χ 1 ↗μ, this] using mul_delta _
Theorem: Submodule.comap_smul
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
h : a ≠ 0
⊢ comap (a • f) p = comap f p
state_after: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
h : a ≠ 0
b : V
⊢ b ∈ comap (a • f) p ↔ b ∈ comap f p
tactic: ext b
state_before: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
h : a ≠ 0
b : V
⊢ b ∈ comap (a • f) p ↔ b ∈ comap f p
state_after: no goals
tactic: simp only [Submodule.mem_comap, p.smul_mem_iff h, LinearMap.smul_apply]
Theorem: MonoidHom.tendsto_coe_cofinite_of_discrete
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : T2Space G
H : Type u_2
inst✝ : Group H
f : H →* G
hf : Function.Injective ⇑f
hf' : DiscreteTopology ↥f.range
⊢ Tendsto (⇑f) cofinite (cocompact G)
state_after: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : T2Space G
H : Type u_2
inst✝ : Group H
f : H →* G
hf' : DiscreteTopology ↥f.range
hf : Function.Injective ⇑f.rangeRestrict
⊢ Tendsto (⇑f) cofinite (cocompact G)
tactic: replace hf : Function.Injective f.rangeRestrict := by simpa
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : T2Space G
H : Type u_2
inst✝ : Group H
f : H →* G
hf' : DiscreteTopology ↥f.range
hf : Function.Injective ⇑f.rangeRestrict
⊢ Tendsto (⇑f) cofinite (cocompact G)
state_after: no goals
tactic: exact f.range.tendsto_coe_cofinite_of_discrete.comp hf.tendsto_cofinite
Theorem: Ordinal.derivBFamily_fp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ f i hi (o.derivBFamily f a) = o.derivBFamily f a
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯) (o.derivBFamily f a) = o.derivBFamily f a
tactic: rw [← familyOfBFamily_enum o f]
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯) (o.derivBFamily f a) = o.derivBFamily f a
state_after: case H
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ IsNormal (o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯))
tactic: apply derivFamily_fp
state_before: case H
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ IsNormal (o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯))
state_after: case H
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ IsNormal (f i ?H.hi)

case H.hi
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ i < o
tactic: rw [familyOfBFamily_enum]
state_before: case H
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ IsNormal (f i ?H.hi)

case H.hi
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
H : IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ i < o
state_after: no goals
tactic: exact H
Theorem: IsAddUnit.sub_self
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit a
⊢ a / a = 1
state_after: no goals
tactic: rw [div_eq_mul_inv, h.mul_inv_cancel]