ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IntermediateField.isSeparable_adjoin_simple_iff_isSeparable
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
⊢ Algebra.IsSeparable F ↥F⟮x⟯ ↔ IsSeparable F x
state_after: case refine_1
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
x✝ : Algebra.IsSeparable F ↥F⟮x⟯
⊢ IsSeparable F x

case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : IsSeparable F x
⊢ Algebra.IsSeparable F ↥F⟮x⟯
tactic: refine ⟨fun _ ↦ ?_, fun hsep ↦ ?_⟩
Theorem: Nat.choose_eq_asc_factorial_div_factorial
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n k : ℕ
⊢ (n + k).choose k = (n + 1).ascFactorial k / k !
state_after: n k : ℕ
⊢ k ! * (n + k).choose k = k ! * ((n + 1).ascFactorial k / k !)
tactic: apply Nat.mul_left_cancel k.factorial_pos
state_before: n k : ℕ
⊢ k ! * (n + k).choose k = k ! * ((n + 1).ascFactorial k / k !)
state_after: n k : ℕ
⊢ (n + 1).ascFactorial k = k ! * ((n + 1).ascFactorial k / k !)
tactic: rw [← ascFactorial_eq_factorial_mul_choose]
state_before: n k : ℕ
⊢ (n + 1).ascFactorial k = k ! * ((n + 1).ascFactorial k / k !)
state_after: no goals
tactic: exact (Nat.mul_div_cancel' <| factorial_dvd_ascFactorial _ _).symm
Theorem: RingHom.map_mulVec
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✝⁴ : Fintype n
inst✝³ : NonAssocSemiring α
inst✝² : NonAssocSemiring β
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f : R →+* S
M : Matrix m n R
v : n → R
i : m
⊢ f ((M *ᵥ v) i) = (M.map ⇑f *ᵥ ⇑f ∘ v) i
state_after: no goals
tactic: simp only [Matrix.mulVec, Matrix.map_apply, RingHom.map_dotProduct, Function.comp]
Theorem: MeasureTheory.memℒp_top_of_bound
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNorm f ⊤ μ < ⊤
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNormEssSup f μ < ⊤
tactic: rw [eLpNorm_exponent_top]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNormEssSup f μ < ⊤
state_after: no goals
tactic: exact eLpNormEssSup_lt_top_of_ae_bound hfC
Theorem: isAddFundamentalDomain_Ioc
File: Mathlib/MeasureTheory/Integral/Periodic.lean

Proof steps:
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
⊢ IsAddFundamentalDomain (↥(zmultiples T)) (Ioc t (t + T)) μ
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
tactic: refine IsAddFundamentalDomain.mk' measurableSet_Ioc.nullMeasurableSet fun x => ?_
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
tactic: have : Bijective (codRestrict (fun n : ℤ => n • T) (AddSubgroup.zmultiples T) _) :=
    (Equiv.ofInjective (fun n : ℤ => n • T) (zsmul_strictMono_left hT).injective).bijective
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! g, g +ᵥ x ∈ Ioc t (t + T)
state_after: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! x_1, codRestrict (fun n => n • T) ↑(zmultiples T) ⋯ x_1 +ᵥ x ∈ Ioc t (t + T)
tactic: refine this.existsUnique_iff.2 ?_
state_before: T : ℝ
hT : 0 < T
t : ℝ
μ : autoParam (Measure ℝ) _auto✝
x : ℝ
this : Bijective (codRestrict (fun n => n • T) ↑(zmultiples T) ⋯)
⊢ ∃! x_1, codRestrict (fun n => n • T) ↑(zmultiples T) ⋯ x_1 +ᵥ x ∈ Ioc t (t + T)
state_after: no goals
tactic: simpa only [add_comm x] using existsUnique_add_zsmul_mem_Ioc hT x t
Theorem: smul_sphere
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
⊢ c • sphere x r = sphere (c • x) (‖c‖ * r)
state_after: case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
⊢ 0 • sphere x r = sphere (0 • x) (‖0‖ * r)

case inr
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
c : 𝕜
x : E
r : ℝ
hr : 0 ≤ r
hc : c ≠ 0
⊢ c • sphere x r = sphere (c • x) (‖c‖ * r)
tactic: rcases eq_or_ne c 0 with (rfl | hc)
Theorem: Filter.Eventually.intCast_atTop
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℤ) in atTop, p ↑n
state_after: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℤ) in Filter.comap Int.cast atTop, p ↑n
tactic: rw [← Int.comap_cast_atTop (R := R)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atTop, p x
⊢ ∀ᶠ (n : ℤ) in Filter.comap Int.cast atTop, p ↑n
state_after: no goals
tactic: exact h.comap _
Theorem: CliffordAlgebraQuaternion.quaternionBasis_i
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (1, 0) * (ι (Q c₁ c₂)) (1, 0) = c₁ • 1
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((1, 0).1 * (1, 0).1) + c₂ * ((1, 0).2 * (1, 0).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₁
tactic: rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((1, 0).1 * (1, 0).1) + c₂ * ((1, 0).2 * (1, 0).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₁
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (0, 1) * (ι (Q c₁ c₂)) (0, 1) = c₂ • 1
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((0, 1).1 * (0, 1).1) + c₂ * ((0, 1).2 * (0, 1).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₂
tactic: rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) (c₁ * ((0, 1).1 * (0, 1).1) + c₂ * ((0, 1).2 * (0, 1).2)) =
    (algebraMap R (CliffordAlgebra (Q c₁ c₂))) c₂
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (ι (Q c₁ c₂)) (0, 1) * (ι (Q c₁ c₂)) (1, 0) = -((ι (Q c₁ c₂)) (1, 0) * (ι (Q c₁ c₂)) (0, 1))
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) ((Q c₁ c₂) ((0, 1) + (1, 0)) - (Q c₁ c₂) (0, 1) - (Q c₁ c₂) (1, 0)) = 0
tactic: rw [eq_neg_iff_add_eq_zero, ι_mul_ι_add_swap, QuadraticMap.polar]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
⊢ (algebraMap R (CliffordAlgebra (Q c₁ c₂))) ((Q c₁ c₂) ((0, 1) + (1, 0)) - (Q c₁ c₂) (0, 1) - (Q c₁ c₂) (1, 0)) = 0
state_after: no goals
tactic: simp
Theorem: Matrix.charmatrix_fromBlocks
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M : Matrix n n R
i j : n
⊢ (fromBlocks M₁₁ M₁₂ M₂₁ M₂₂).charmatrix = fromBlocks M₁₁.charmatrix (-M₁₂.map ⇑C) (-M₂₁.map ⇑C) M₂₂.charmatrix
state_after: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M : Matrix n n R
i j : n
⊢ (scalar (m ⊕ n)) X - C.mapMatrix (fromBlocks M₁₁ M₁₂ M₂₁ M₂₂) =
    fromBlocks ((scalar m) X - C.mapMatrix M₁₁) (-M₁₂.map ⇑C) (-M₂₁.map ⇑C) ((scalar n) X - C.mapMatrix M₂₂)
tactic: simp only [charmatrix]
state_before: R : Type u_1
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
m : Type u_3
n : Type u_4
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Fintype m
inst✝ : Fintype n
M₁₁ : Matrix m m R
M₁₂ : Matrix m n R
M₂₁ : Matrix n m R
M₂₂ M : Matrix n n R
i j : n
⊢ (scalar (m ⊕ n)) X - C.mapMatrix (fromBlocks M₁₁ M₁₂ M₂₁ M₂₂) =
    fromBlocks ((scalar m) X - C.mapMatrix M₁₁) (-M₁₂.map ⇑C) (-M₂₁.map ⇑C) ((scalar n) X - C.mapMatrix M₂₂)
state_after: no goals
tactic: ext (i|i) (j|j) : 2 <;> simp [diagonal]
Theorem: groupCohomology.map_one_fst_of_isTwoCocycle
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G✝ : Type u
inst✝⁴ : CommRing k
inst✝³ : Group G✝
A✝ : Rep k G✝
G : Type u_1
A : Type u_2
inst✝² : Monoid G
inst✝¹ : AddCommGroup A
inst✝ : MulAction G A
f : G × G → A
hf : IsTwoCocycle f
g : G
⊢ f (1, g) = f (1, 1)
state_after: no goals
tactic: simpa only [one_smul, one_mul, mul_one, add_right_inj] using (hf 1 1 g).symm
Theorem: WeierstrassCurve.twoTorsionPolynomial_disc
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ W.twoTorsionPolynomial.disc = 16 * W.Δ
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (W.a₁ ^ 2 + 4 * W.a₂) ^ 2 * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) ^ 2 - 4 * 4 * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) ^ 3 -
          4 * (W.a₁ ^ 2 + 4 * W.a₂) ^ 3 * (W.a₃ ^ 2 + 4 * W.a₆) -
        27 * 4 ^ 2 * (W.a₃ ^ 2 + 4 * W.a₆) ^ 2 +
      18 * 4 * (W.a₁ ^ 2 + 4 * W.a₂) * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) * (W.a₃ ^ 2 + 4 * W.a₆) =
    16 *
      (-(W.a₁ ^ 2 + 4 * W.a₂) ^ 2 *
              (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2) -
            8 * (2 * W.a₄ + W.a₁ * W.a₃) ^ 3 -
          27 * (W.a₃ ^ 2 + 4 * W.a₆) ^ 2 +
        9 * (W.a₁ ^ 2 + 4 * W.a₂) * (2 * W.a₄ + W.a₁ * W.a₃) * (W.a₃ ^ 2 + 4 * W.a₆))
tactic: simp only [b₂, b₄, b₆, b₈, Δ, twoTorsionPolynomial, Cubic.disc]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (W.a₁ ^ 2 + 4 * W.a₂) ^ 2 * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) ^ 2 - 4 * 4 * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) ^ 3 -
          4 * (W.a₁ ^ 2 + 4 * W.a₂) ^ 3 * (W.a₃ ^ 2 + 4 * W.a₆) -
        27 * 4 ^ 2 * (W.a₃ ^ 2 + 4 * W.a₆) ^ 2 +
      18 * 4 * (W.a₁ ^ 2 + 4 * W.a₂) * (2 * (2 * W.a₄ + W.a₁ * W.a₃)) * (W.a₃ ^ 2 + 4 * W.a₆) =
    16 *
      (-(W.a₁ ^ 2 + 4 * W.a₂) ^ 2 *
              (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2) -
            8 * (2 * W.a₄ + W.a₁ * W.a₃) ^ 3 -
          27 * (W.a₃ ^ 2 + 4 * W.a₆) ^ 2 +
        9 * (W.a₁ ^ 2 + 4 * W.a₂) * (2 * W.a₄ + W.a₁ * W.a₃) * (W.a₃ ^ 2 + 4 * W.a₆))
state_after: no goals
tactic: ring1
Theorem: continuous_sInf_rng
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
T : Set (TopologicalSpace β)
⊢ Continuous f ↔ ∀ t ∈ T, Continuous f
state_after: no goals
tactic: simp only [continuous_iff_coinduced_le, le_sInf_iff]
Theorem: Set.Finite.subset_toFinset
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
a : α
hs : s✝.Finite
ht : t.Finite
s : Finset α
⊢ s ⊆ ht.toFinset ↔ ↑s ⊆ t
state_after: no goals
tactic: rw [← Finset.coe_subset, Finite.coe_toFinset]
Theorem: MeasureTheory.measure_add_right_null
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
y : G
⊢ μ ((fun x => x * y) ⁻¹' s) = 0 ↔ μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0
state_after: no goals
tactic: simp_rw [← inv_preimage, preimage_preimage, mul_inv_rev, inv_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
y : G
⊢ μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0 ↔ μ s = 0
state_after: no goals
tactic: simp only [measure_inv_null μ, measure_preimage_mul]
Theorem: EMetric.hausdorffEdist_self
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ hausdorffEdist s s = 0
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ ∀ i ∈ s, infEdist i s = 0
tactic: simp only [hausdorffEdist_def, sup_idem, ENNReal.iSup_eq_zero]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ ∀ i ∈ s, infEdist i s = 0
state_after: no goals
tactic: exact fun x hx => infEdist_zero_of_mem hx
Theorem: Ergodic.ae_empty_or_univ_of_image_ae_le'
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Ergodic f μ
hs : MeasurableSet s
hs' : f '' s ≤ᶠ[ae μ] s
h_fin : μ s ≠ ⊤
⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ
state_after: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Ergodic f μ
hs : MeasurableSet s
h_fin : μ s ≠ ⊤
hs' : s ≤ᶠ[ae μ] f ⁻¹' s
⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ
tactic: replace hs' : s ≤ᵐ[μ] f ⁻¹' s :=
    (HasSubset.Subset.eventuallyLE (subset_preimage_image f s)).trans
      (hf.quasiMeasurePreserving.preimage_mono_ae hs')
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Ergodic f μ
hs : MeasurableSet s
h_fin : μ s ≠ ⊤
hs' : s ≤ᶠ[ae μ] f ⁻¹' s
⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ
state_after: no goals
tactic: exact ae_empty_or_univ_of_ae_le_preimage' hf hs hs' h_fin
Theorem: Substring.ValidFor.nextn_stop
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l m r : List Char
x✝ : Substring
h : ValidFor l m r x✝
n : Nat
⊢ x✝.nextn (n + 1) { byteIdx := utf8Len m } = { byteIdx := utf8Len m }
state_after: no goals
tactic: simp [Substring.nextn, h.next_stop, h.nextn_stop n]
Theorem: div_le_comm₀
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
hc : 0 < c
⊢ a / b ≤ c ↔ a / c ≤ b
state_after: no goals
tactic: rw [div_le_iff hb, div_le_iff' hc]
Theorem: Ideal.prod_top_top
File: Mathlib/RingTheory/Ideal/Prod.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I I' : Ideal R
J J' : Ideal S
⊢ ∀ (x : R × S), x ∈ ⊤.prod ⊤ ↔ x ∈ ⊤
state_after: no goals
tactic: simp
Theorem: CochainComplex.HomComplex.Cochain.rightShift_units_smul
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n' + a = n
x : Rˣ
⊢ (x • γ).rightShift a n' hn' = x • γ.rightShift a n' hn'
state_after: no goals
tactic: apply rightShift_smul
Theorem: BoxIntegral.Integrable.hasIntegral
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
h : Integrable I l f vol
⊢ HasIntegral I l f vol (integral I l f vol)
state_after: ι : 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
h : Integrable I l f vol
⊢ HasIntegral I l f vol (Exists.choose h)
tactic: rw [integral, dif_pos h]
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
h : Integrable I l f vol
⊢ HasIntegral I l f vol (Exists.choose h)
state_after: no goals
tactic: exact Classical.choose_spec h
Theorem: one_lt_one_div
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h1 : 0 < a
h2 : a < 1
⊢ 1 < 1 / a
state_after: no goals
tactic: rwa [lt_one_div (@zero_lt_one α _ _ _ _ _) h1, one_div_one]
Theorem: List.maximum_cons
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l✝ : List α
a✝ m a : α
l : List α
⊢ [a].maximum = max ↑a [].maximum
state_after: no goals
tactic: simp [@max_eq_left (WithBot α) _ _ _ bot_le]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l✝ : List α
a✝ m a : α
l tl : List α
hd : α
ih : (a :: tl).maximum = max (↑a) tl.maximum
⊢ (a :: (tl ++ [hd])).maximum = max (↑a) (tl ++ [hd]).maximum
state_after: no goals
tactic: rw [← cons_append, maximum_concat, ih, maximum_concat, max_assoc]
Theorem: contMDiffAt_iff_contDiffAt
File: Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³¹ : NormedAddCommGroup E
inst✝³⁰ : NormedSpace 𝕜 E
H : Type u_3
inst✝²⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝²⁸ : TopologicalSpace M
inst✝²⁷ : ChartedSpace H M
inst✝²⁶ : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝²⁵ : NormedAddCommGroup E'
inst✝²⁴ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝²³ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝²² : TopologicalSpace M'
inst✝²¹ : ChartedSpace H' M'
inst✝²⁰ : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type u_9
inst✝¹⁷ : TopologicalSpace G
J : ModelWithCorners 𝕜 F G
N : Type u_10
inst✝¹⁶ : TopologicalSpace N
inst✝¹⁵ : ChartedSpace G N
inst✝¹⁴ : SmoothManifoldWithCorners J N
F' : Type u_11
inst✝¹³ : NormedAddCommGroup F'
inst✝¹² : NormedSpace 𝕜 F'
G' : Type u_12
inst✝¹¹ : TopologicalSpace G'
J' : ModelWithCorners 𝕜 F' G'
N' : Type u_13
inst✝¹⁰ : TopologicalSpace N'
inst✝⁹ : ChartedSpace G' N'
inst✝⁸ : SmoothManifoldWithCorners J' N'
F₁ : Type u_14
inst✝⁷ : NormedAddCommGroup F₁
inst✝⁶ : NormedSpace 𝕜 F₁
F₂ : Type u_15
inst✝⁵ : NormedAddCommGroup F₂
inst✝⁴ : NormedSpace 𝕜 F₂
F₃ : Type u_16
inst✝³ : NormedAddCommGroup F₃
inst✝² : NormedSpace 𝕜 F₃
F₄ : Type u_17
inst✝¹ : NormedAddCommGroup F₄
inst✝ : NormedSpace 𝕜 F₄
f✝ f₁ : M → M'
s t : Set M
x✝ : M
m n : ℕ∞
f : E → E'
x : E
⊢ ContMDiffAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f x ↔ ContDiffAt 𝕜 n f x
state_after: no goals
tactic: rw [← contMDiffWithinAt_univ, contMDiffWithinAt_iff_contDiffWithinAt, contDiffWithinAt_univ]
Theorem: Set.nsmul_subset_nsmul
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0
tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0
state_after: no goals
tactic: exact Subset.rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ n * s ⊆ t ^ (n + 1)
state_after: no goals
tactic: exact mul_subset_mul (pow_subset_pow hst _) hst
Theorem: Function.bUnion_ptsOfPeriod
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x✝ y : α
m n : ℕ
x : α
⊢ x ∈ ⋃ n, ⋃ (_ : n > 0), ptsOfPeriod f n ↔ x ∈ periodicPts f
state_after: no goals
tactic: simp [mem_periodicPts]
Theorem: TopologicalSpace.IsTopologicalBasis.diff_empty
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ IsTopologicalBasis (s \ {∅})
state_after: case refine_1
α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ ∀ t₁ ∈ s \ {∅}, ∀ t₂ ∈ s \ {∅}, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s \ {∅}, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

case refine_2
α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
s : Set (Set α)
h : IsTopologicalBasis s
⊢ t = generateFrom (s \ {∅})
tactic: refine ⟨?_, by rw [sUnion_diff_singleton_empty, h.sUnion_eq], ?_⟩
Theorem: HomologicalComplex₂.totalFlipIso_hom_f_D₁
File: Mathlib/Algebra/Homology/TotalComplexSymmetry.lean

Proof steps:
state_before: C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_5, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
j j' : J
⊢ (K.totalFlipIso c).hom.f j ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIso c).hom.f j'
state_after: no goals
tactic: apply totalFlipIsoX_hom_D₁
Theorem: Orientation.inner_rotation_pi_div_two_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ ⟪(o.rotation ↑(π / 2)) x, x⟫_ℝ = 0
state_after: no goals
tactic: rw [rotation_pi_div_two, inner_rightAngleRotation_self]