ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: OrthonormalBasis.coe_ofRepr
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
⊢ ⇑{ repr := e } = fun i => e.symm (EuclideanSpace.single i 1)
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
⊢ (fun i => EquivLike.coe e.symm (EuclideanSpace.single i 1)) = fun i =>
    EquivLike.coe e.symm (EuclideanSpace.single i 1)
tactic: dsimp only [DFunLike.coe]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
⊢ (fun i => EquivLike.coe e.symm (EuclideanSpace.single i 1)) = fun i =>
    EquivLike.coe e.symm (EuclideanSpace.single i 1)
state_after: case h
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
x✝ : ι
⊢ EquivLike.coe e.symm (EuclideanSpace.single x✝ 1) = EquivLike.coe e.symm (EuclideanSpace.single x✝ 1)
tactic: funext
state_before: case h
ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
x✝ : ι
⊢ EquivLike.coe e.symm (EuclideanSpace.single x✝ 1) = EquivLike.coe e.symm (EuclideanSpace.single x✝ 1)
state_after: no goals
tactic: congr!
Theorem: UniqueFactorizationMonoid.count_normalizedFactors_eq'
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
p x : R
hp : p = 0 ∨ Irreducible p
hnorm : normalize p = p
n : ℕ
hle : p ^ n ∣ x
hlt : ¬p ^ (n + 1) ∣ x
⊢ count p (normalizedFactors x) = n
state_after: case inl
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
x : R
n : ℕ
hnorm : normalize 0 = 0
hle : 0 ^ n ∣ x
hlt : ¬0 ^ (n + 1) ∣ x
⊢ count 0 (normalizedFactors x) = n

case inr
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
p x : R
hnorm : normalize p = p
n : ℕ
hle : p ^ n ∣ x
hlt : ¬p ^ (n + 1) ∣ x
hp : Irreducible p
⊢ count p (normalizedFactors x) = n
tactic: rcases hp with (rfl | hp)
Theorem: eq_of_norm_div_le_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
h : ‖a / b‖ ≤ 0
⊢ a = b
state_after: no goals
tactic: rwa [← div_eq_one, ← norm_le_zero_iff'']
Theorem: AkraBazziRecurrence.isTheta_deriv_rpow_p_mul_one_add_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (fun x => ‖deriv (fun z => z ^ p * (1 + ε z)) x‖) =Θ[atTop] fun z => z ^ (p - 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 + ε z)) =Θ[atTop] fun z => z ^ (p - 1)
tactic: refine IsTheta.norm_left ?_
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 + ε z)) =Θ[atTop] fun z => z ^ (p - 1)
state_after: no goals
tactic: calc (fun x => deriv (fun z => z ^ p * (1 + ε z)) x) =Θ[atTop] fun z => p * z ^ (p-1) :=
            (isEquivalent_deriv_rpow_p_mul_one_add_smoothingFn hp).isTheta
    _ =Θ[atTop] fun z => z ^ (p-1) :=
            IsTheta.const_mul_left hp <| isTheta_refl _ _
Theorem: Ordinal.lt_mul_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : c.IsLimit
⊢ a < b * c ↔ ∃ c' < c, a < b * c'
state_after: no goals
tactic: simpa only [not_forall₂, not_le, bex_def] using not_congr (@mul_le_of_limit b c a h)
Theorem: Surreal.Multiplication.P3_of_le_left
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂
state_after: case inl
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl✝ : x₁ ≤ x₂.moveLeft i
hl : x₁ < x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂

case inr
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
he : x₁ ≈ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂
tactic: obtain (hl|he) := lt_or_equiv_of_le hl
Theorem: AddLECancellable.add_tsub_cancel_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a + b = a + b
state_after: no goals
tactic: rw [add_comm]
Theorem: Polynomial.mul_divByMonic_cancel_left
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
⊢ q * p /ₘ q = p
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ q * p /ₘ q = p
tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ q * p /ₘ q = p
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ degree 0 < q.degree
tactic: refine (div_modByMonic_unique _ 0 hmo ⟨by rw [zero_add], ?_⟩).1
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ degree 0 < q.degree
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ ⊥ < q.degree
tactic: rw [degree_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hmo : q.Monic
a✝ : Nontrivial R
⊢ ⊥ < q.degree
state_after: no goals
tactic: exact Ne.bot_lt fun h => hmo.ne_zero (degree_eq_bot.1 h)
Theorem: MeasureTheory.Submartingale.stoppedValue_leastGE_eLpNorm_le
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ eLpNorm (stoppedValue f (leastGE f r i)) 1 μ ≤ 2 * μ Set.univ * ENNReal.ofReal (r + ↑R)
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (x : Ω), stoppedValue f (leastGE f r i) x ∂μ
tactic: refine eLpNorm_one_le_of_le' ((hf.stoppedValue_leastGE r).integrable _) ?_
    (norm_stoppedValue_leastGE_le hr hf0 hbdd i)
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (x : Ω), stoppedValue f (leastGE f r i) x ∂μ
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (x : Ω) in Set.univ, stoppedValue f (leastGE f r i) x ∂μ
tactic: rw [← integral_univ]
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (x : Ω) in Set.univ, stoppedValue f (leastGE f r i) x ∂μ
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (ω : Ω) in Set.univ, stoppedValue f (leastGE f r 0) ω ∂μ
tactic: refine le_trans ?_ ((hf.stoppedValue_leastGE r).setIntegral_le (zero_le _) MeasurableSet.univ)
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hr : 0 ≤ r
hf0 : f 0 = 0
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
i : ℕ
⊢ 0 ≤ ∫ (ω : Ω) in Set.univ, stoppedValue f (leastGE f r 0) ω ∂μ
state_after: no goals
tactic: simp_rw [stoppedValue, leastGE, hitting_of_le le_rfl, hf0, integral_zero', le_rfl]
Theorem: Stream'.Seq.map_cons
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ map f (cons a ⟨s, al⟩) = cons (f a) (map f ⟨s, al⟩)
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map f (cons a ⟨s, al⟩)) = ↑(cons (f a) (map f ⟨s, al⟩))
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map f (cons a ⟨s, al⟩)) = ↑(cons (f a) (map f ⟨s, al⟩))
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map f) (some a :: s) = some (f a) :: Stream'.map (Option.map f) s
tactic: dsimp [cons, map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map f) (some a :: s) = some (f a) :: Stream'.map (Option.map f) s
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ Option.map f (some a) :: Stream'.map (Option.map f) s = some (f a) :: Stream'.map (Option.map f) s
tactic: rw [Stream'.map_cons]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Stream' (Option α)
al : s.IsSeq
⊢ Option.map f (some a) :: Stream'.map (Option.map f) s = some (f a) :: Stream'.map (Option.map f) s
state_after: no goals
tactic: rfl
Theorem: Polynomial.roots_expand_image_frobenius
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
p n : ℕ
inst✝² : ExpChar R p
f : R[X]
inst✝¹ : PerfectRing R p
inst✝ : DecidableEq R
⊢ Finset.image (⇑(frobenius R p)) ((expand R p) f).roots.toFinset = f.roots.toFinset
state_after: no goals
tactic: rw [Finset.image_toFinset, roots_expand_map_frobenius,
      (roots f).toFinset_nsmul _ (expChar_pos R p).ne']
Theorem: DirectSum.IsInternal.ofBijective_coeLinearMap_of_ne
File: Mathlib/Algebra/DirectSum/Module.lean

Proof steps:
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
i j : ι
hij : i ≠ j
x : ↥(A i)
⊢ ((LinearEquiv.ofBijective (coeLinearMap A) h).symm ↑x) j = 0
state_after: no goals
tactic: rw [← coeLinearMap_of, LinearEquiv.ofBijective_symm_apply_apply, of_eq_of_ne i j _ hij]
Theorem: lineDifferentiableWithinAt_smul_iff
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f : E → F
s : Set E
x v : E
f' : F
c : 𝕜
hc : c ≠ 0
h : LineDifferentiableWithinAt 𝕜 f s x (c • v)
⊢ LineDifferentiableWithinAt 𝕜 f s x v
state_after: no goals
tactic: simpa [smul_smul, inv_mul_cancel hc] using h.smul (c ⁻¹)
Theorem: Real.ennnorm_eq_ofReal
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ↑‖r‖₊ = ENNReal.ofReal r
state_after: no goals
tactic: rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
Theorem: thickenedIndicatorAux_le_one
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
x : α
⊢ thickenedIndicatorAux δ E x ≤ 1
state_after: no goals
tactic: apply @tsub_le_self _ _ _ _ (1 : ℝ≥0∞)
Theorem: nhdsWithin_eq_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
a : α
s t u : Set α
h₀ : a ∈ s
h₁ : IsOpen s
h₂ : t ∩ s = u ∩ s
⊢ 𝓝[t] a = 𝓝[u] a
state_after: no goals
tactic: rw [nhdsWithin_restrict t h₀ h₁, nhdsWithin_restrict u h₀ h₁, h₂]
Theorem: Pell.is_pell_solution_iff_mem_unitary
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
a : ℤ√d
⊢ a.re ^ 2 - d * a.im ^ 2 = 1 ↔ a ∈ unitary (ℤ√d)
state_after: no goals
tactic: rw [← norm_eq_one_iff_mem_unitary, norm_def, sq, sq, ← mul_assoc]
Theorem: Mathlib.Meta.NormNum.intPow_ofNat
File: Mathlib/Tactic/NormNum/Pow.lean

Proof steps:
state_before: a b c : ℕ
h1 : a.pow b = c
⊢ (Int.ofNat a).pow b = Int.ofNat c
state_after: no goals
tactic: simp [← h1]
Theorem: SetTheory.PGame.lt_or_equiv_or_gf
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y ⧏ x
state_after: xl xr : Type u
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
tactic: rw [lf_iff_lt_or_fuzzy, Fuzzy.swap_iff]
state_before: xl xr : Type u
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: no goals
tactic: exact lt_or_equiv_or_gt_or_fuzzy x y
Theorem: CategoryTheory.Arrow.mk_eq
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝ : Category.{v, u} T
f : Arrow T
⊢ mk f.hom = f
state_after: case mk
T : Type u
inst✝ : Category.{v, u} T
left✝ right✝ : T
hom✝ : (𝟭 T).obj left✝ ⟶ (𝟭 T).obj right✝
⊢ mk { left := left✝, right := right✝, hom := hom✝ }.hom = { left := left✝, right := right✝, hom := hom✝ }
tactic: cases f
state_before: case mk
T : Type u
inst✝ : Category.{v, u} T
left✝ right✝ : T
hom✝ : (𝟭 T).obj left✝ ⟶ (𝟭 T).obj right✝
⊢ mk { left := left✝, right := right✝, hom := hom✝ }.hom = { left := left✝, right := right✝, hom := hom✝ }
state_after: no goals
tactic: rfl
Theorem: IsSubgroup.mem_norm_comm
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝ : Group G
s : Set G
hs : IsNormalSubgroup s
a b : G
hab : a * b ∈ s
⊢ b * a ∈ s
state_after: no goals
tactic: simpa using (hs.normal (a * b) hab a⁻¹)
Theorem: Ordinal.mul_le_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : b.IsLimit
H : ∀ b' < b, a * b' ≤ c
⊢ ¬c < a * b
state_after: no goals
tactic: induction a using inductionOn with
      | H α r =>
        induction b using inductionOn with
        | H β s =>
          exact mul_le_of_limit_aux h H
Theorem: Pell.xn_modEq_x4n_add
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (4 * n + j) + xn a1 (2 * n + j) ≡ xn a1 j + xn a1 (2 * n + j) [MOD xn a1 n]
state_after: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (4 * n + j) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]
tactic: refine @ModEq.trans _ _ 0 _ ?_ (by rw [add_comm]; exact (xn_modEq_x2n_add _ _ _).symm)
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (4 * n + j) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]
state_after: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (2 * n + (2 * n + j)) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]
tactic: rw [show 4 * n = 2 * n + 2 * n from right_distrib 2 2 n, add_assoc]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (2 * n + (2 * n + j)) + xn a1 (2 * n + j) ≡ 0 [MOD xn a1 n]
state_after: no goals
tactic: apply xn_modEq_x2n_add
Theorem: isAtom_iff_le_of_ge
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : Preorder α
inst✝ : OrderBot α
a b✝ x b : α
⊢ b < a → b = ⊥ ↔ b ≠ ⊥ → b ≤ a → a ≤ b
state_after: no goals
tactic: simp only [Ne, @not_imp_comm (b = ⊥), Classical.not_imp, lt_iff_le_not_le]
Theorem: Nat.leRecOn_surjective
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ k : ℕ
p q : ℕ → Prop
C : ℕ → Sort u_1
n m : ℕ
hnm : n ≤ m
next : {k : ℕ} → C k → C (k + 1)
Hnext : ∀ (n : ℕ), Surjective next
⊢ Surjective (leRecOn hnm fun {k} => next)
state_after: no goals
tactic: induction hnm with
  | refl =>
    intro x
    refine ⟨x, ?_⟩
    rw [leRecOn_self]
  | step hnm ih =>
    intro x
    obtain ⟨w, rfl⟩ := Hnext _ x
    obtain ⟨x, rfl⟩ := ih w
    refine ⟨x, ?_⟩
    rw [leRecOn_succ]
Theorem: PrimeMultiset.prod_add
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: u v : PrimeMultiset
⊢ (u + v).prod = u.prod * v.prod
state_after: u v : PrimeMultiset
⊢ (coePNatMonoidHom (u + v)).prod = u.prod * v.prod
tactic: change (coePNatMonoidHom (u + v)).prod = _
state_before: u v : PrimeMultiset
⊢ (coePNatMonoidHom (u + v)).prod = u.prod * v.prod
state_after: u v : PrimeMultiset
⊢ (coePNatMonoidHom u + coePNatMonoidHom v).prod = u.prod * v.prod
tactic: rw [coePNatMonoidHom.map_add]
state_before: u v : PrimeMultiset
⊢ (coePNatMonoidHom u + coePNatMonoidHom v).prod = u.prod * v.prod
state_after: no goals
tactic: exact Multiset.prod_add _ _
Theorem: cycleType_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
⊢ (finRotate (n + 2)).cycleType = {n + 2}
state_after: n : ℕ
⊢ ↑[n + 2] = {n + 2}
tactic: rw [isCycle_finRotate.cycleType, support_finRotate, ← Fintype.card, Fintype.card_fin]
state_before: n : ℕ
⊢ ↑[n + 2] = {n + 2}
state_after: no goals
tactic: rfl
Theorem: interior_frontier
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
⊢ interior (frontier s) = ∅
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
⊢ interior (frontier s) = ∅
tactic: have A : frontier s = s \ interior s := h.frontier_eq
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
⊢ interior (frontier s) = ∅
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
⊢ interior (frontier s) = ∅
tactic: have B : interior (frontier s) ⊆ interior s := by rw [A]; exact interior_mono diff_subset
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
⊢ interior (frontier s) = ∅
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
⊢ interior (frontier s) = ∅
tactic: have C : interior (frontier s) ⊆ frontier s := interior_subset
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
⊢ interior (frontier s) = ∅
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
this : interior (frontier s) ⊆ interior s ∩ (s \ interior s)
⊢ interior (frontier s) = ∅
tactic: have : interior (frontier s) ⊆ interior s ∩ (s \ interior s) :=
    subset_inter B (by simpa [A] using C)
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : IsClosed s
A : frontier s = s \ interior s
B : interior (frontier s) ⊆ interior s
C : interior (frontier s) ⊆ frontier s
this : interior (frontier s) ⊆ interior s ∩ (s \ interior s)
⊢ interior (frontier s) = ∅
state_after: no goals
tactic: rwa [inter_diff_self, subset_empty_iff] at this
Theorem: Holor.slice_unitVec_mul
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : i = j
⊢ (unitVec d j ⊗ x).slice i hid t = (if i = j then x else 0) t
state_after: no goals
tactic: simp [slice, mul, HolorIndex.take, unitVec, HolorIndex.drop, h]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ (unitVec d j ⊗ x).slice i hid t = (if i = j then x else 0) t
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ 0 = 0 t
tactic: simp [slice, mul, HolorIndex.take, unitVec, HolorIndex.drop, h]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ 0 = 0 t
state_after: no goals
tactic: rfl