ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BoxIntegral.hasIntegral_zero
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
⊢ HasIntegral I l (fun x => 0) vol 0
state_after: no goals
tactic: simpa only [← (vol I).map_zero] using hasIntegral_const (0 : E)
Theorem: Finset.toFinset_bitIndices_twoPowSum
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Finset ℕ
n : ℕ
s : Finset ℕ
⊢ (∑ i ∈ s, 2 ^ i).bitIndices.toFinset = s
state_after: no goals
tactic: simp [← (geomSum_injective rfl.le).eq_iff, List.sum_toFinset _ Nat.bitIndices_sorted.nodup]
Theorem: ProbabilityTheory.measure_eq_zero_or_one_or_top_of_indepSet_self
File: Mathlib/Probability/Independence/ZeroOne.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
s : ι → MeasurableSpace Ω
m m0 : MeasurableSpace Ω
κ : Kernel α Ω
μα : Measure α
μ : Measure Ω
t : Set Ω
h_indep : IndepSet t t μ
⊢ μ t = 0 ∨ μ t = 1 ∨ μ t = ⊤
state_after: no goals
tactic: simpa only [ae_dirac_eq, Filter.eventually_pure]
    using Kernel.measure_eq_zero_or_one_or_top_of_indepSet_self h_indep
Theorem: Matrix.conjTranspose_natCast
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : StarRing α
d : ℕ
⊢ (↑d)ᴴ = ↑d
state_after: no goals
tactic: simp [conjTranspose, Matrix.map_natCast, diagonal_natCast]
Theorem: Nat.choose_eq_zero_of_lt
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n k : ℕ
hk : n + 1 < k + 1
⊢ (n + 1).choose (k + 1) = 0
state_after: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
⊢ (n + 1).choose (k + 1) = 0
tactic: have hnk : n < k := lt_of_succ_lt_succ hk
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
⊢ (n + 1).choose (k + 1) = 0
state_after: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
hnk1 : n < k + 1
⊢ (n + 1).choose (k + 1) = 0
tactic: have hnk1 : n < k + 1 := lt_of_succ_lt hk
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
hnk1 : n < k + 1
⊢ (n + 1).choose (k + 1) = 0
state_after: no goals
tactic: rw [choose_succ_succ, choose_eq_zero_of_lt hnk, choose_eq_zero_of_lt hnk1]
Theorem: Matrix.diagonal_transvection_induction_of_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
inst✝ : Fintype n
P : Matrix n n 𝕜 → Prop
M : Matrix n n 𝕜
hMdet : M.det ≠ 0
hdiag : ∀ (D : n → 𝕜), (diagonal D).det ≠ 0 → P (diagonal D)
htransvec : ∀ (t : TransvectionStruct n 𝕜), P t.toMatrix
hmul : ∀ (A B : Matrix n n 𝕜), A.det ≠ 0 → B.det ≠ 0 → P A → P B → P (A * B)
⊢ P M
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
inst✝ : Fintype n
P : Matrix n n 𝕜 → Prop
M : Matrix n n 𝕜
hMdet : M.det ≠ 0
hdiag : ∀ (D : n → 𝕜), (diagonal D).det ≠ 0 → P (diagonal D)
htransvec : ∀ (t : TransvectionStruct n 𝕜), P t.toMatrix
hmul : ∀ (A B : Matrix n n 𝕜), A.det ≠ 0 → B.det ≠ 0 → P A → P B → P (A * B)
Q : Matrix n n 𝕜 → Prop := fun N => N.det ≠ 0 ∧ P N
⊢ P M
tactic: let Q : Matrix n n 𝕜 → Prop := fun N => det N ≠ 0 ∧ P N
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
inst✝ : Fintype n
P : Matrix n n 𝕜 → Prop
M : Matrix n n 𝕜
hMdet : M.det ≠ 0
hdiag : ∀ (D : n → 𝕜), (diagonal D).det ≠ 0 → P (diagonal D)
htransvec : ∀ (t : TransvectionStruct n 𝕜), P t.toMatrix
hmul : ∀ (A B : Matrix n n 𝕜), A.det ≠ 0 → B.det ≠ 0 → P A → P B → P (A * B)
Q : Matrix n n 𝕜 → Prop := fun N => N.det ≠ 0 ∧ P N
this : Q M
⊢ P M
state_after: no goals
tactic: exact this.2
Theorem: HurwitzZeta.completedHurwitzZetaEven_eq
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedHurwitzZetaEven a s = completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s - 1 / (1 - s)
state_after: a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).f₀ / 2 -
      ((hurwitzEvenFEPair a).ε / (↑(hurwitzEvenFEPair a).k - s / 2)) • (hurwitzEvenFEPair a).g₀ / 2 =
    completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s - 1 / (1 - s)
tactic: rw [completedHurwitzZetaEven, WeakFEPair.Λ, sub_div, sub_div]
state_before: a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).f₀ / 2 -
      ((hurwitzEvenFEPair a).ε / (↑(hurwitzEvenFEPair a).k - s / 2)) • (hurwitzEvenFEPair a).g₀ / 2 =
    completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s - 1 / (1 - s)
state_after: case e_a
a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).f₀ / 2 =
    completedHurwitzZetaEven₀ a s - (if a = 0 then 1 else 0) / s

case e_a
a : UnitAddCircle
s : ℂ
⊢ ((hurwitzEvenFEPair a).ε / (↑(hurwitzEvenFEPair a).k - s / 2)) • (hurwitzEvenFEPair a).g₀ / 2 = 1 / (1 - s)
tactic: congr 1
Theorem: IsCyclotomicExtension.Rat.discr_prime_pow_ne_two'
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hk : p ^ (k + 1) ≠ 2
⊢ Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =
    (-1) ^ (φ (↑p ^ (k + 1)) / 2) * ↑↑p ^ (↑p ^ k * ((↑p - 1) * (k + 1) - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hk : p ^ (k + 1) ≠ 2
⊢ Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =
    Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis
tactic: rw [← discr_prime_pow_ne_two hζ (cyclotomic.irreducible_rat (p ^ (k + 1)).pos) hk]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hk : p ^ (k + 1) ≠ 2
⊢ Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =
    Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis
state_after: no goals
tactic: exact hζ.discr_zeta_eq_discr_zeta_sub_one.symm
Theorem: groupCohomology.mem_range_of_mem_twoCoboundaries
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
h : f ∈ twoCoboundaries A
⊢ (twoCocycles A).subtype f ∈ LinearMap.range (dOne A)
state_after: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : G → CoeSort.coe A
⊢ (twoCocycles A).subtype ((LinearMap.codRestrict (twoCocycles A) (dOne A) ⋯) x) ∈ LinearMap.range (dOne A)
tactic: rcases h with ⟨x, rfl⟩
state_before: case intro
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : G → CoeSort.coe A
⊢ (twoCocycles A).subtype ((LinearMap.codRestrict (twoCocycles A) (dOne A) ⋯) x) ∈ LinearMap.range (dOne A)
state_after: no goals
tactic: exact ⟨x, rfl⟩
Theorem: singleton_div_ball
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / ball y δ = ball (x / y) δ
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, inv_ball, singleton_mul_ball]
Theorem: MeasureTheory.Lp.simpleFunc.sub_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : ↥(simpleFunc E p μ)
⊢ ↑(toSimpleFunc (f - g)) =ᶠ[ae μ] ↑(toSimpleFunc f) - ↑(toSimpleFunc g)
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑↑↑(f - g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑↑(↑f - ↑g) a✝ = (↑↑↑f - ↑↑↑g) a✝ → ↑(toSimpleFunc (f - g)) a✝ = (↑(toSimpleFunc f) - ↑(toSimpleFunc g)) a✝
tactic: filter_upwards [toSimpleFunc_eq_toFun (f - g), toSimpleFunc_eq_toFun f,
    toSimpleFunc_eq_toFun g, Lp.coeFn_sub (f : Lp E p μ) g] with _
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑↑↑(f - g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑↑(↑f - ↑g) a✝ = (↑↑↑f - ↑↑↑g) a✝ → ↑(toSimpleFunc (f - g)) a✝ = (↑(toSimpleFunc f) - ↑(toSimpleFunc g)) a✝
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑(↑↑f - ↑↑g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝ → ↑(toSimpleFunc (f - g)) a✝ = ↑(toSimpleFunc f) a✝ - ↑(toSimpleFunc g) a✝
tactic: simp only [AddSubgroup.coe_sub, Pi.sub_apply]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : ↥(simpleFunc E p μ)
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑(↑↑f - ↑↑g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝ → ↑(toSimpleFunc (f - g)) a✝ = ↑(toSimpleFunc f) a✝ - ↑(toSimpleFunc g) a✝
state_after: no goals
tactic: repeat' intro h; rw [h]
Theorem: MeasureTheory.union_ae_eq_univ_of_ae_eq_univ_right
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] univ
⊢ s ∪ t =ᶠ[ae μ] univ
state_after: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] univ
⊢ univ = s ∪ univ
tactic: convert ae_eq_set_union (ae_eq_refl s) h
state_before: case h.e'_5
α : Type u_1
β : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
h : t =ᶠ[ae μ] univ
⊢ univ = s ∪ univ
state_after: no goals
tactic: rw [union_univ]
Theorem: MeasureTheory.null_iff_of_isAddLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
s : Set G
hs : IsOpen s
⊢ μ s = 0 ↔ s = ∅ ∨ μ = 0
state_after: case inl
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
inst✝³ : Group G
inst✝² : TopologicalGroup G
s : Set G
hs : IsOpen s
inst✝¹ : IsMulLeftInvariant 0
inst✝ : Regular 0
⊢ 0 s = 0 ↔ s = ∅ ∨ 0 = 0

case inr
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
s : Set G
hs : IsOpen s
hμ : NeZero μ
⊢ μ s = 0 ↔ s = ∅ ∨ μ = 0
tactic: rcases eq_zero_or_neZero μ with rfl|hμ
Theorem: String.firstDiffPos_eq
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: a b : String
⊢ a.firstDiffPos b = { byteIdx := utf8Len (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) a.data b.data).fst }
state_after: no goals
tactic: simpa [firstDiffPos] using
    firstDiffPos_loop_eq [] [] a.1 b.1 ((utf8Len a.1).min (utf8Len b.1)) 0 rfl rfl (by simp)
Theorem: Fintype.piFinset_nonempty
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
⊢ (piFinset s).Nonempty ↔ ∀ (a : α), (s a).Nonempty
state_after: no goals
tactic: simp [Finset.Nonempty, Classical.skolem]
Theorem: Ordinal.nfp_id
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u_1}
⊢ nfp id a = id a
state_after: f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u_1}
⊢ (sup fun n => id a) = id a
tactic: simp_rw [← sup_iterate_eq_nfp, iterate_id]
state_before: f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u_1}
⊢ (sup fun n => id a) = id a
state_after: no goals
tactic: exact sup_const a
Theorem: Set.iUnion_range_eq_iUnion
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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
⊢ (⋃ y, range fun x => ↑(f x y)) = ⋃ x, C x
state_after: case h
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (x ∈ ⋃ y, range fun x => ↑(f x y)) ↔ x ∈ ⋃ x, C x
tactic: ext x
state_before: case h
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (x ∈ ⋃ y, range fun x => ↑(f x y)) ↔ x ∈ ⋃ x, C x
state_after: case h
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (∃ i, x ∈ range fun x => ↑(f x i)) ↔ ∃ i, x ∈ C i
tactic: rw [mem_iUnion, mem_iUnion]
state_before: case h
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (∃ i, x ∈ range fun x => ↑(f x i)) ↔ ∃ i, x ∈ C i
state_after: case h.mp
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (∃ i, x ∈ range fun x => ↑(f x i)) → ∃ i, x ∈ C i

case h.mpr
α : 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
C : ι → Set α
f : (x : ι) → β → ↑(C x)
hf : ∀ (x : ι), Surjective (f x)
x : α
⊢ (∃ i, x ∈ C i) → ∃ i, x ∈ range fun x => ↑(f x i)
tactic: constructor
Theorem: Set.Ioc_insert_left
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ insert a (Ioc a b) = Icc a b
state_after: no goals
tactic: rw [insert_eq, union_comm, Ioc_union_left h]
Theorem: pow_padicValNat_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n : ℕ
⊢ p ^ padicValNat p n ∣ n
state_after: case inl
p : ℕ
⊢ p ^ padicValNat p 0 ∣ 0

case inr
p n : ℕ
hn : n > 0
⊢ p ^ padicValNat p n ∣ n
tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: case inr
p n : ℕ
hn : n > 0
⊢ p ^ padicValNat p n ∣ n
state_after: case inr.inl
n : ℕ
hn : n > 0
⊢ 1 ^ padicValNat 1 n ∣ n

case inr.inr
p n : ℕ
hn : n > 0
hp : p ≠ 1
⊢ p ^ padicValNat p n ∣ n
tactic: rcases eq_or_ne p 1 with (rfl | hp)
state_before: case inr.inr
p n : ℕ
hn : n > 0
hp : p ≠ 1
⊢ p ^ padicValNat p n ∣ n
state_after: no goals
tactic: rw [multiplicity.pow_dvd_iff_le_multiplicity, padicValNat_def'] <;> assumption
Theorem: OrthonormalBasis.det_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ (e.adjustToOrientation x).toBasis.det = e.toBasis.det ∨ (e.adjustToOrientation x).toBasis.det = -e.toBasis.det
state_after: no goals
tactic: simpa using e.toBasis.det_adjustToOrientation x
Theorem: UniformContinuous.const_zsmul
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ ↑n
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ n
tactic: simp_rw [zpow_natCast]
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ n
state_after: no goals
tactic: exact hf.pow_const _
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ Int.negSucc n
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => (f x ^ (n + 1))⁻¹
tactic: simp_rw [zpow_negSucc]
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => (f x ^ (n + 1))⁻¹
state_after: no goals
tactic: exact (hf.pow_const _).inv
Theorem: Submodule.equivOpposite_symm_apply
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
p q : Submodule R Aᵐᵒᵖ
⊢ { toFun := fun p => op (comap (↑(opLinearEquiv R)) p), invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p),
          left_inv := ⋯, right_inv := ⋯ }.toFun
      (p + q) =
    { toFun := fun p => op (comap (↑(opLinearEquiv R)) p), invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p),
            left_inv := ⋯, right_inv := ⋯ }.toFun
        p +
      { toFun := fun p => op (comap (↑(opLinearEquiv R)) p),
            invFun := fun p => comap (↑(opLinearEquiv R).symm) (unop p), left_inv := ⋯, right_inv := ⋯ }.toFun
        q
state_after: no goals
tactic: simp [comap_equiv_eq_map_symm, ← op_add]
Theorem: fderivWithin_zero_of_not_differentiableWithinAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ fderivWithin 𝕜 f s x = 0
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬DifferentiableWithinAt 𝕜 f s x
this : ¬∃ f', HasFDerivWithinAt f f' s x
⊢ fderivWithin 𝕜 f s x = 0
tactic: have : ¬∃ f', HasFDerivWithinAt f f' s x := h
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : ¬DifferentiableWithinAt 𝕜 f s x
this : ¬∃ f', HasFDerivWithinAt f f' s x
⊢ fderivWithin 𝕜 f s x = 0
state_after: no goals
tactic: simp [fderivWithin, this]
Theorem: sub_lt_sub_iff_left
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a✝ b c a : α
⊢ a / b < a / c ↔ c < b
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
    inv_mul_cancel_left, inv_lt_inv_iff]
Theorem: Ordinal.one_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: a : Ordinal.{u_1}
⊢ 1 ^ a = 1
state_after: no goals
tactic: induction a using limitRecOn with
  | H₁ => simp only [opow_zero]
  | H₂ _ ih =>
    simp only [opow_succ, ih, mul_one]
  | H₃ b l IH =>
    refine eq_of_forall_ge_iff fun c => ?_
    rw [opow_le_of_limit Ordinal.one_ne_zero l]
    exact ⟨fun H => by simpa only [opow_zero] using H 0 l.pos, fun H b' h => by rwa [IH _ h]⟩
Theorem: OreLocalization.oreDiv_one_smul
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : M
x : OreLocalization S X
⊢ (r /ₒ 1) • x = r • x
state_after: case c
R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : M
r' : X
s : ↥S
⊢ (r /ₒ 1) • (r' /ₒ s) = r • (r' /ₒ s)
tactic: induction' x using OreLocalization.ind with r' s
state_before: case c
R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : M
r' : X
s : ↥S
⊢ (r /ₒ 1) • (r' /ₒ s) = r • (r' /ₒ s)
state_after: no goals
tactic: rw [smul_oreDiv, oreDiv_smul_oreDiv, mul_one, smul_eq_mul, mul_one]