ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: riemannZeta_one_sub
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
hs' : s ≠ 1
⊢ riemannZeta (1 - s) = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s * Complex.cos (↑π * s / 2) * riemannZeta s
state_after: no goals
tactic: rw [riemannZeta, hurwitzZetaEven_one_sub 0 hs (Or.inr hs'), cosZeta_zero, hurwitzZetaEven_zero]
Theorem: BoxIntegral.Prepartition.IsPartition.inf
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h₁ : π₁.IsPartition
h₂ : π₂.IsPartition
⊢ (π₁ ⊓ π₂).iUnion = ↑I
state_after: no goals
tactic: simp [h₁.iUnion_eq, h₂.iUnion_eq]
Theorem: Ordinal.natCast_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: m n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: no goals
tactic: rw [← Cardinal.ord_nat, ← Cardinal.ord_nat, Cardinal.ord_le_ord, Cardinal.natCast_le]
Theorem: MeasureTheory.Memℒp.integral_indicator_norm_ge_nonneg_le_of_meas
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
p : ℝ≥0∞
f : α → β
hf : Memℒp f 1 μ
hmeas : StronglyMeasurable f
ε : ℝ
hε : 0 < ε
M : ℝ
hM : ∫⁻ (x : α), ↑‖{x | M ≤ ↑‖f x‖₊}.indicator f x‖₊ ∂μ ≤ ENNReal.ofReal ε
⊢ ∫⁻ (x : α), ↑‖{x | max M 0 ≤ ↑‖f x‖₊}.indicator f x‖₊ ∂μ ≤ ENNReal.ofReal ε
state_after: no goals
tactic: simpa
Theorem: SimpleGraph.edgeFinset_bot
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑G.edgeSet
inst✝¹ : Fintype ↑G₁.edgeSet
inst✝ : Fintype ↑G₂.edgeSet
⊢ ⊥.edgeFinset = ∅
state_after: no goals
tactic: simp [edgeFinset]
Theorem: ProbabilityTheory.condexpKernel_apply_eq_condDistrib
File: Mathlib/Probability/Kernel/Condexp.lean

Proof steps:
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
ω : Ω
⊢ (condexpKernel μ m) ω = (condDistrib id id μ) (id ω)
state_after: no goals
tactic: simp_rw [condexpKernel, Kernel.comap_apply]
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_integral_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
tactic: rw [tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ),
      Tendsto (fun i => ∫ (x : Ω), f x ∂↑((toFiniteMeasure ∘ μs) i)) F (𝓝 (∫ (x : Ω), f x ∂↑μ.toFiniteMeasure))) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
tactic: rw [FiniteMeasure.tendsto_iff_forall_integral_tendsto]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ),
      Tendsto (fun i => ∫ (x : Ω), f x ∂↑((toFiniteMeasure ∘ μs) i)) F (𝓝 (∫ (x : Ω), f x ∂↑μ.toFiniteMeasure))) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: no goals
tactic: rfl
Theorem: finrank_eq_one_iff'
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ finrank K V = 1 ↔ ∃ v, v ≠ 0 ∧ ∀ (w : V), ∃ c, c • v = w
state_after: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ finrank K V = 1 ↔ Module.rank K V = 1
tactic: rw [← rank_eq_one_iff]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ finrank K V = 1 ↔ Module.rank K V = 1
state_after: no goals
tactic: exact toNat_eq_iff one_ne_zero
Theorem: LieAlgebra.Orthogonal.soIndefiniteEquiv_apply
File: Mathlib/Algebra/Lie/Classical.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((soIndefiniteEquiv p q R hi) A) = (Pso p q R i)⁻¹ * ↑A * Pso p q R i
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv (indefiniteDiagonal p q R) (Pso p q R i) (invertiblePso p q R hi)) A) =
    (Pso p q R i)⁻¹ * ↑A * Pso p q R i
tactic: rw [soIndefiniteEquiv, LieEquiv.trans_apply, LieEquiv.ofEq_apply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : ↥(so' p q R)
⊢ ↑((skewAdjointMatricesLieSubalgebraEquiv (indefiniteDiagonal p q R) (Pso p q R i) (invertiblePso p q R hi)) A) =
    (Pso p q R i)⁻¹ * ↑A * Pso p q R i
state_after: no goals
tactic: erw [skewAdjointMatricesLieSubalgebraEquiv_apply]
Theorem: Ordinal.enum_zero_eq_bot
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{?u.114338}
ho : 0 < o
⊢ 0 < type fun x x_1 => x < x_1
state_after: no goals
tactic: rwa [type_lt]
Theorem: Set.biInter_pair
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
a b : α
s : α → Set β
⊢ ⋂ x ∈ {a, b}, s x = s a ∩ s b
state_after: no goals
tactic: rw [biInter_insert, biInter_singleton]
Theorem: Algebra.FinitePresentation.quotient
File: Mathlib/RingTheory/FinitePresentation.lean

Proof steps:
state_before: R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
I : Ideal A
h : I.FG
inst✝ : FinitePresentation R A
⊢ ∃ n f, Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
state_after: case intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
I : Ideal A
h : I.FG
inst✝ : FinitePresentation R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
⊢ ∃ n f, Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
tactic: obtain ⟨n, f, hf⟩ := FinitePresentation.out (R := R) (A := A)
state_before: case intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
I : Ideal A
h : I.FG
inst✝ : FinitePresentation R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
⊢ ∃ n f, Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
state_after: case intro.intro.refine_1
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
I : Ideal A
h : I.FG
inst✝ : FinitePresentation R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
⊢ Surjective ⇑((Ideal.Quotient.mkₐ R I).comp f)

case intro.intro.refine_2
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
I : Ideal A
h : I.FG
inst✝ : FinitePresentation R A
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ⇑f ∧ (RingHom.ker f.toRingHom).FG
⊢ (RingHom.ker ((Ideal.Quotient.mkₐ R I).comp f).toRingHom).FG
tactic: refine ⟨n, (Ideal.Quotient.mkₐ R I).comp f, ?_, ?_⟩
Theorem: Cubic.C_mul_prod_X_sub_C_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }.toPoly
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +
      C w * -(C x * C y * C z)
tactic: simp only [toPoly, C_neg, C_add, C_mul]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +
      C w * -(C x * C y * C z)
state_after: no goals
tactic: ring1
Theorem: isLowerSet_compl
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 α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ IsUpperSet s
state_after: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ s = sᶜᶜ
tactic: convert h.compl
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
h : IsLowerSet sᶜ
⊢ s = sᶜᶜ
state_after: no goals
tactic: rw [compl_compl]
Theorem: PMF.toOuterMeasure_ofMultiset_apply
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ (ofMultiset s hs).toOuterMeasure t =
    (∑' (x : α), ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s))) / ↑(Multiset.card s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ ∑' (x : α), t.indicator (⇑(ofMultiset s hs)) x =
    ∑' (i : α), ↑(Multiset.count i (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
tactic: simp_rw [div_eq_mul_inv, ← ENNReal.tsum_mul_right, toOuterMeasure_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
⊢ ∑' (x : α), t.indicator (⇑(ofMultiset s hs)) x =
    ∑' (i : α), ↑(Multiset.count i (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
x : α
⊢ t.indicator (⇑(ofMultiset s hs)) x = ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
tactic: refine tsum_congr fun x => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
t : Set α
x : α
⊢ t.indicator (⇑(ofMultiset s hs)) x = ↑(Multiset.count x (Multiset.filter (fun x => x ∈ t) s)) * (↑(Multiset.card s))⁻¹
state_after: no goals
tactic: by_cases hx : x ∈ t <;> simp [Set.indicator, hx, div_eq_mul_inv]
Theorem: Filter.map₂_sup_left
File: Mathlib/Order/Filter/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
⊢ map₂ m (f₁ ⊔ f₂) g = map₂ m f₁ g ⊔ map₂ m f₂ g
state_after: no goals
tactic: simp_rw [← map_prod_eq_map₂, sup_prod, map_sup]
Theorem: Matrix.det_updateColumn_smul'
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ ((s • M).updateColumn j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s ^ (Fintype.card n - 1) * (Mᵀ.updateRow j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det
tactic: rw [← det_transpose, ← updateRow_transpose, transpose_smul, det_updateRow_smul']
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s ^ (Fintype.card n - 1) * (Mᵀ.updateRow j u).det = s ^ (Fintype.card n - 1) * (M.updateColumn j u).det
state_after: no goals
tactic: simp [updateRow_transpose, det_transpose]
Theorem: StrictConcaveOn.slope_lt_of_hasDerivWithinAt_Ioi
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConcaveOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hf' : HasDerivWithinAt f f' (Ioi x) x
⊢ slope f x y < f'
state_after: no goals
tactic: simpa only [Pi.neg_def, slope_neg, neg_neg] using
    neg_lt_neg (hfc.neg.lt_slope_of_hasDerivWithinAt_Ioi hx hy hxy hf'.neg)
Theorem: UnitalShelf.act_idem
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: S : Type u_1
inst✝ : UnitalShelf S
x : S
⊢ x ◃ x = x
state_after: no goals
tactic: rw [← act_one x, ← Shelf.self_distrib, act_one]
Theorem: nsmul_pos
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
k : ℕ
hk : k ≠ 0
⊢ 1 < a ^ k
state_after: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
hk : l.succ ≠ 0
⊢ 1 < a ^ l.succ
tactic: rcases Nat.exists_eq_succ_of_ne_zero hk with ⟨l, rfl⟩
state_before: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
hk : l.succ ≠ 0
⊢ 1 < a ^ l.succ
state_after: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
⊢ 1 < a ^ l.succ
tactic: clear hk
state_before: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
⊢ 1 < a ^ l.succ
state_after: case intro.zero
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
⊢ 1 < a ^ Nat.succ 0

case intro.succ
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
IH : 1 < a ^ l.succ
⊢ 1 < a ^ (l + 1).succ
tactic: induction' l with l IH
Theorem: Finset.Icc_eq_cons_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a ≤ b
⊢ Icc a b = cons b (Ico a b) ⋯
state_after: no goals
tactic: classical rw [cons_eq_insert, Ico_insert_right h]
Theorem: EuclideanGeometry.angle_eq_pi_iff_sbtw
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ ∠ p₁ p₂ p₃ = π ↔ Sbtw ℝ p₁ p₂ p₃
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ ∠ p₁ p₂ p₃ = π → Sbtw ℝ p₁ p₂ p₃
tactic: refine ⟨?_, fun h => h.angle₁₂₃_eq_pi⟩
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ ∠ p₁ p₂ p₃ = π → Sbtw ℝ p₁ p₂ p₃
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ (p₁ -ᵥ p₂ ≠ 0 ∧ ∃ r < 0, p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)) → Sbtw ℝ p₁ p₂ p₃
tactic: rw [angle, angle_eq_pi_iff]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ (p₁ -ᵥ p₂ ≠ 0 ∧ ∃ r < 0, p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)) → Sbtw ℝ p₁ p₂ p₃
state_after: case intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
hp₁p₂ : p₁ -ᵥ p₂ ≠ 0
r : ℝ
hr : r < 0
hp₃p₂ : p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)
⊢ Sbtw ℝ p₁ p₂ p₃
tactic: rintro ⟨hp₁p₂, r, hr, hp₃p₂⟩
state_before: case intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
hp₁p₂ : p₁ -ᵥ p₂ ≠ 0
r : ℝ
hr : r < 0
hp₃p₂ : p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)
⊢ Sbtw ℝ p₁ p₂ p₃
state_after: case intro.intro.intro.refine_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
hp₁p₂ : p₁ -ᵥ p₂ ≠ 0
r : ℝ
hr : r < 0
hp₃p₂ : p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)
⊢ (AffineMap.lineMap p₁ p₃) (1 / (1 - r)) = p₂

case intro.intro.intro.refine_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
hp₁p₂ : p₁ -ᵥ p₂ ≠ 0
r : ℝ
hr : r < 0
hp₃p₂ : p₃ -ᵥ p₂ = r • (p₁ -ᵥ p₂)
⊢ p₂ ≠ p₃
tactic: refine ⟨⟨1 / (1 - r), ⟨div_nonneg zero_le_one (sub_nonneg.2 (hr.le.trans zero_le_one)),
    (div_le_one (sub_pos.2 (hr.trans zero_lt_one))).2 ((le_sub_self_iff 1).2 hr.le)⟩, ?_⟩,
    (vsub_ne_zero.1 hp₁p₂).symm, ?_⟩
Theorem: padicValNat.one
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
⊢ padicValNat p 1 = 0
state_after: p : ℕ
⊢ (if h : p ≠ 1 ∧ 0 < 1 then (multiplicity p 1).get ⋯ else 0) = 0
tactic: unfold padicValNat
state_before: p : ℕ
⊢ (if h : p ≠ 1 ∧ 0 < 1 then (multiplicity p 1).get ⋯ else 0) = 0
state_after: case pos
p : ℕ
h✝ : p ≠ 1 ∧ 0 < 1
⊢ (multiplicity p 1).get ⋯ = 0

case neg
p : ℕ
h✝ : ¬(p ≠ 1 ∧ 0 < 1)
⊢ 0 = 0
tactic: split_ifs
Theorem: HasDerivAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

Proof steps:
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hx : f x ≠ 0
⊢ HasDerivAt (fun y => Real.log (f y)) (f' / f x) x
state_after: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) Set.univ x
tactic: rw [← hasDerivWithinAt_univ] at *
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) Set.univ x
state_after: no goals
tactic: exact hf.log hx
Theorem: maximal_orthonormal_iff_orthogonalComplement_eq_bot
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
⊢ (∀ u ⊇ v, Orthonormal 𝕜 Subtype.val → u = v) ↔ (span 𝕜 v)ᗮ = ⊥
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
⊢ (∀ u ⊇ v, Orthonormal 𝕜 Subtype.val → u = v) ↔ ∀ x ∈ (span 𝕜 v)ᗮ, x = 0
tactic: rw [Submodule.eq_bot_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
⊢ (∀ u ⊇ v, Orthonormal 𝕜 Subtype.val → u = v) ↔ ∀ x ∈ (span 𝕜 v)ᗮ, x = 0
state_after: case mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
⊢ (∀ u ⊇ v, Orthonormal 𝕜 Subtype.val → u = v) → ∀ x ∈ (span 𝕜 v)ᗮ, x = 0

case mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
v : Set E
hv : Orthonormal 𝕜 Subtype.val
⊢ (∀ x ∈ (span 𝕜 v)ᗮ, x = 0) → ∀ u ⊇ v, Orthonormal 𝕜 Subtype.val → u = v
tactic: constructor
Theorem: ProbabilityTheory.IdentDistrib.measure_mem_eq
File: Mathlib/Probability/IdentDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
h : IdentDistrib f g μ ν
s : Set γ
hs : MeasurableSet s
⊢ μ (f ⁻¹' s) = ν (g ⁻¹' s)
state_after: no goals
tactic: rw [← Measure.map_apply_of_aemeasurable h.aemeasurable_fst hs, ←
    Measure.map_apply_of_aemeasurable h.aemeasurable_snd hs, h.map_eq]
Theorem: Multiset.card_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
e : s = 0
⊢ card s = 0
state_after: no goals
tactic: simp [e]
Theorem: Basis.det_self
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
⊢ e.det ⇑e = 1
state_after: no goals
tactic: simp [e.det_apply]