ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddCommMonCat.uliftFunctor_obj
File: Mathlib/Algebra/Category/MonCat/Basic.lean

Proof steps:
state_before: X : CommMonCat
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : CommMonCat
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.setIntegral_nonpos_le
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f : X → ℝ
s✝ s : Set X
hs : MeasurableSet s
hf : StronglyMeasurable f
hfi : Integrable f μ
⊢ ∫ (x : X) in {y | f y ≤ 0}, f x ∂μ ≤ ∫ (x : X) in s, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f : X → ℝ
s✝ s : Set X
hs : MeasurableSet s
hf : StronglyMeasurable f
hfi : Integrable f μ
⊢ ∫ (x : X), {a | f a ≤ 0}.indicator f x ∂μ ≤ ∫ (x : X), s.indicator f x ∂μ
tactic: rw [← integral_indicator hs, ←
    integral_indicator (hf.measurableSet_le stronglyMeasurable_const)]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f : X → ℝ
s✝ s : Set X
hs : MeasurableSet s
hf : StronglyMeasurable f
hfi : Integrable f μ
⊢ ∫ (x : X), {a | f a ≤ 0}.indicator f x ∂μ ≤ ∫ (x : X), s.indicator f x ∂μ
state_after: no goals
tactic: exact
    integral_mono (hfi.indicator (hf.measurableSet_le stronglyMeasurable_const))
      (hfi.indicator hs) (indicator_nonpos_le_indicator s f)
Theorem: PFunctor.Approx.agree_trival
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
x : CofixA F 0
y : CofixA F 1
⊢ Agree x y
state_after: no goals
tactic: constructor
Theorem: Algebra.TensorProduct.basisAux_map_smul
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
x : A ⊗[R] M
⊢ (basisAux A b) (a • 0) = a • (basisAux A b) 0
state_after: no goals
tactic: simp
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
x✝ : A ⊗[R] M
x : A
y : M
⊢ (basisAux A b) (a • x ⊗ₜ[R] y) = a • (basisAux A b) (x ⊗ₜ[R] y)
state_after: no goals
tactic: simp only [TensorProduct.smul_tmul', basisAux_tmul, smul_assoc]
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
x✝ x y : A ⊗[R] M
hx : (basisAux A b) (a • x) = a • (basisAux A b) x
hy : (basisAux A b) (a • y) = a • (basisAux A b) y
⊢ (basisAux A b) (a • (x + y)) = a • (basisAux A b) (x + y)
state_after: no goals
tactic: simp [hx, hy]
Theorem: Fintype.card_le_card_of_rightTotal_unique
File: Mathlib/Combinatorics/Enumerative/DoubleCounting.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
r : α → β → Prop
h₁ : RightTotal r
h₂ : RightUnique r
⊢ ∀ b ∈ univ, ∃ a ∈ univ, r a b
state_after: no goals
tactic: simpa using h₁
Theorem: ContinuousLinearMap.hasFPowerSeriesOnBall
File: Mathlib/Analysis/Analytic/Linear.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
f : E →L[𝕜] F
x : E
⊢ ⊤ ≤ (f.fpowerSeries x).radius
state_after: no goals
tactic: simp
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
f : E →L[𝕜] F
x y✝ : E
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => (f.fpowerSeries x (n + 2)) fun x => y✝)
    (f (x + y✝) - ∑ i ∈ Finset.range 2, (f.fpowerSeries x i) fun x => y✝)
state_after: no goals
tactic: simp [Finset.sum_range_succ, ← sub_sub, hasSum_zero, fpowerSeries]
Theorem: MeasureTheory.sigmaFiniteTrim_mono
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ SigmaFinite (μ.trim hm)
state_after: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ (μ.trim hm).FiniteSpanningSetsIn Set.univ
tactic: refine ⟨⟨?_⟩⟩
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
⊢ (μ.trim hm).FiniteSpanningSetsIn Set.univ
state_after: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ (μ.trim hm) (spanningSets (μ.trim ⋯) i) < ⊤
tactic: refine
    { set := spanningSets (μ.trim (hm₂.trans hm))
      set_mem := fun _ => Set.mem_univ _
      finite := fun i => ?_
      spanning := iUnion_spanningSets _ }
state_before: α : Type u_1
m✝ m0✝ : MeasurableSpace α
μ✝ : Measure α
s : Set α
m m₂ m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
hm₂ : m₂ ≤ m
inst✝ : SigmaFinite (μ.trim ⋯)
i : ℕ
⊢ (μ.trim hm) (spanningSets (μ.trim ⋯) i) < ⊤
state_after: no goals
tactic: calc
    (μ.trim hm) (spanningSets (μ.trim (hm₂.trans hm)) i) =
        ((μ.trim hm).trim hm₂) (spanningSets (μ.trim (hm₂.trans hm)) i) := by
      rw [@trim_measurableSet_eq α m₂ m (μ.trim hm) _ hm₂ (measurable_spanningSets _ _)]
    _ = (μ.trim (hm₂.trans hm)) (spanningSets (μ.trim (hm₂.trans hm)) i) := by
      rw [@trim_trim _ _ μ _ _ hm₂ hm]
    _ < ∞ := measure_spanningSets_lt_top _ _
Theorem: Finset.orderEmbOfFin_singleton
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a : α
i : Fin 1
⊢ ({a}.orderEmbOfFin ⋯) i = a
state_after: no goals
tactic: rw [Subsingleton.elim i ⟨0, Nat.zero_lt_one⟩, orderEmbOfFin_zero _ Nat.zero_lt_one,
    min'_singleton]
Theorem: Set.image_finset_prod_pi
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
⊢ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S = ∏ i ∈ l, S i
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
x✝ : α
⊢ x✝ ∈ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S ↔ x✝ ∈ ∏ i ∈ l, S i
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
l : Finset ι
S : ι → Set α
x✝ : α
⊢ x✝ ∈ (fun f => ∏ i ∈ l, f i) '' (↑l).pi S ↔ x✝ ∈ ∏ i ∈ l, S i
state_after: no goals
tactic: simp_rw [mem_finset_prod, mem_image, mem_pi, exists_prop, Finset.mem_coe]
Theorem: WeakDual.CharacterSpace.continuousMapEval_bijective
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

Proof steps:
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : RCLike 𝕜
⊢ Bijective ⇑(continuousMapEval X 𝕜)
state_after: case refine_1
X : Type u_1
𝕜 : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : RCLike 𝕜
x y : X
hxy : (continuousMapEval X 𝕜) x = (continuousMapEval X 𝕜) y
⊢ x = y

case refine_2
X : Type u_1
𝕜 : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : CompactSpace X
inst✝¹ : T2Space X
inst✝ : RCLike 𝕜
φ : ↑(characterSpace 𝕜 C(X, 𝕜))
⊢ ∃ a, (continuousMapEval X 𝕜) a = φ
tactic: refine ⟨fun x y hxy => ?_, fun φ => ?_⟩
Theorem: derivWithin_add_const
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => f y + c) s x = derivWithin f s x
state_after: no goals
tactic: simp only [derivWithin, fderivWithin_add_const hxs]
Theorem: Nat.prod_primeFactors_gcd_mul_prod_primeFactors_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m✝ n✝ p : ℕ
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
⊢ (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f = m.primeFactors.prod f * n.primeFactors.prod f
state_after: case inl
a b m n✝ p : ℕ
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : ℕ → β
⊢ (gcd 0 n).primeFactors.prod f * (0 * n).primeFactors.prod f = (primeFactors 0).prod f * n.primeFactors.prod f

case inr
a b m✝ n✝ p : ℕ
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm₀ : m ≠ 0
⊢ (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f = m.primeFactors.prod f * n.primeFactors.prod f
tactic: obtain rfl | hm₀ := eq_or_ne m 0
state_before: case inr
a b m✝ n✝ p : ℕ
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm₀ : m ≠ 0
⊢ (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f = m.primeFactors.prod f * n.primeFactors.prod f
state_after: case inr.inl
a b m✝ n p : ℕ
β : Type u_1
inst✝ : CommMonoid β
m : ℕ
f : ℕ → β
hm₀ : m ≠ 0
⊢ (m.gcd 0).primeFactors.prod f * (m * 0).primeFactors.prod f = m.primeFactors.prod f * (primeFactors 0).prod f

case inr.inr
a b m✝ n✝ p : ℕ
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm₀ : m ≠ 0
hn₀ : n ≠ 0
⊢ (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f = m.primeFactors.prod f * n.primeFactors.prod f
tactic: obtain rfl | hn₀ := eq_or_ne n 0
Theorem: Num.cast_ofZNum
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ZNum
⊢ ↑(ofZNum n) = ↑(↑n).toNat
state_after: no goals
tactic: rw [← cast_to_nat, ofZNum_toNat]
Theorem: Set.mem_neg_vadd_set_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s t A B : Set β
a : α
x : β
⊢ x ∈ a⁻¹ • A ↔ a • x ∈ A
state_after: no goals
tactic: simp only [← image_smul, mem_image, inv_smul_eq_iff, exists_eq_right]
Theorem: Valued.integer_isOpen
File: Mathlib/Topology/Algebra/Valued/ValuationTopology.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ IsOpen ↑v.integer
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ ∀ x ∈ ↑v.integer, ↑v.integer ∈ 𝓝 x
tactic: rw [isOpen_iff_mem_nhds]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
⊢ ∀ x ∈ ↑v.integer, ↑v.integer ∈ 𝓝 x
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
hx : x ∈ ↑v.integer
⊢ ↑v.integer ∈ 𝓝 x
tactic: intro x hx
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
hx : x ∈ ↑v.integer
⊢ ↑v.integer ∈ 𝓝 x
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
hx : x ∈ ↑v.integer
⊢ ∃ γ, {y | v (y - x) < ↑γ} ⊆ ↑v.integer
tactic: rw [mem_nhds]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
hx : x ∈ ↑v.integer
⊢ ∃ γ, {y | v (y - x) < ↑γ} ⊆ ↑v.integer
state_after: no goals
tactic: exact ⟨1,
    fun y hy => (sub_add_cancel y x).symm ▸ le_trans (map_add _ _ _) (max_le (le_of_lt hy) hx)⟩
Theorem: tendsto_natCast_div_add_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝⁵ : DivisionRing 𝕜
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : CharZero 𝕜
inst✝² : Algebra ℝ 𝕜
inst✝¹ : ContinuousSMul ℝ 𝕜
inst✝ : TopologicalDivisionRing 𝕜
x : 𝕜
⊢ Tendsto (fun n => ↑n / (↑n + x)) atTop (𝓝 1)
state_after: case convert_2
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝⁵ : DivisionRing 𝕜
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : CharZero 𝕜
inst✝² : Algebra ℝ 𝕜
inst✝¹ : ContinuousSMul ℝ 𝕜
inst✝ : TopologicalDivisionRing 𝕜
x : 𝕜
⊢ ℕ → 𝕜

case convert_5
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝⁵ : DivisionRing 𝕜
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : CharZero 𝕜
inst✝² : Algebra ℝ 𝕜
inst✝¹ : ContinuousSMul ℝ 𝕜
inst✝ : TopologicalDivisionRing 𝕜
x : 𝕜
n : ℕ
hn : n ≠ 0
⊢ ?convert_2 n = ↑n / (↑n + x)

case convert_6
α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝⁵ : DivisionRing 𝕜
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : CharZero 𝕜
inst✝² : Algebra ℝ 𝕜
inst✝¹ : ContinuousSMul ℝ 𝕜
inst✝ : TopologicalDivisionRing 𝕜
x : 𝕜
⊢ Tendsto ?convert_2 atTop (𝓝 1)
tactic: convert Tendsto.congr' ((eventually_ne_atTop 0).mp (eventually_of_forall fun n hn ↦ _)) _
Theorem: CategoryTheory.IsHomLift.lift_comp_eqToHom_iff
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S S' : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
h : S = S'
hφ' : p.IsHomLift (f ≫ eqToHom h) φ
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
hφ' : p.IsHomLift (f ≫ eqToHom ⋯) φ
⊢ p.IsHomLift f φ
tactic: subst h
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
hφ' : p.IsHomLift (f ≫ eqToHom ⋯) φ
⊢ p.IsHomLift f φ
state_after: no goals
tactic: simpa using hφ'
Theorem: Finset.weightedVSubOfPoint_map
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
b : P
⊢ ((map e s₂).weightedVSubOfPoint p b) w = (s₂.weightedVSubOfPoint (p ∘ ⇑e) b) (w ∘ ⇑e)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
b : P
⊢ ∑ i ∈ map e s₂, w i • (p i -ᵥ b) = ∑ i ∈ s₂, (w ∘ ⇑e) i • ((p ∘ ⇑e) i -ᵥ b)
tactic: simp_rw [weightedVSubOfPoint_apply]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
b : P
⊢ ∑ i ∈ map e s₂, w i • (p i -ᵥ b) = ∑ i ∈ s₂, (w ∘ ⇑e) i • ((p ∘ ⇑e) i -ᵥ b)
state_after: no goals
tactic: exact Finset.sum_map _ _ _
Theorem: Prod.smul_mk_zero
File: Mathlib/Algebra/GroupWithZero/Action/Prod.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
α : Type u_3
β✝ : Type u_4
inst✝⁶ : SMul M α
inst✝⁵ : SMul M β✝
inst✝⁴ : SMul N α
inst✝³ : SMul N β✝
a✝ : M
x : α × β✝
β : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid β
inst✝ : DistribMulAction M β
a : M
b : α
⊢ a • (b, 0) = (a • b, 0)
state_after: no goals
tactic: rw [Prod.smul_mk, smul_zero]
Theorem: Real.arctan_add_eq_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x y : ℝ
h : 1 < x * y
hx : 0 < x
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
state_after: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
tactic: have hy : 0 < y := by
    have := mul_pos_iff.mp (zero_lt_one.trans h)
    simpa [hx, hx.asymm]
state_before: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
state_after: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan x⁻¹ + arctan y⁻¹ = arctan ((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
tactic: have k := arctan_add (mul_inv x y ▸ inv_lt_one h)
state_before: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan x⁻¹ + arctan y⁻¹ = arctan ((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
state_after: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
tactic: rw [arctan_inv_of_pos hx, arctan_inv_of_pos hy, show _ + _ = π - (arctan x + arctan y) by ring,
    sub_eq_iff_eq_add, ← sub_eq_iff_eq_add', sub_eq_add_neg, ← arctan_neg, add_comm] at k
state_before: x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ arctan x + arctan y = arctan ((x + y) / (1 - x * y)) + π
state_after: case h.e'_3.h.e'_5.h.e'_1
x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ (x + y) / (1 - x * y) = -((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))
tactic: convert k.symm using 3
state_before: case h.e'_3.h.e'_5.h.e'_1
x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ (x + y) / (1 - x * y) = -((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))
state_after: case h.e'_3.h.e'_5.h.e'_1
x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ (x + y) / (1 - x * y) = (-x + -y) / (x * y - 1)
tactic: field_simp
state_before: case h.e'_3.h.e'_5.h.e'_1
x y : ℝ
h : 1 < x * y
hx : 0 < x
hy : 0 < y
k : arctan (-((x⁻¹ + y⁻¹) / (1 - x⁻¹ * y⁻¹))) + π = arctan x + arctan y
⊢ (x + y) / (1 - x * y) = (-x + -y) / (x * y - 1)
state_after: no goals
tactic: rw [show -x + -y = -(x + y) by ring, show x * y - 1 = -(1 - x * y) by ring, neg_div_neg_eq]
Theorem: pow_eq_pow_iff_of_ne_zero
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
hn : n ≠ 0
hne : Even n ∧ ¬Odd n
⊢ a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n
state_after: no goals
tactic: simp only [*, and_true, ← abs_eq_abs,
    ← pow_left_inj (abs_nonneg a) (abs_nonneg b) hn, hne.1.pow_abs]
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
hn✝ : n ≠ 0
hn : Odd n ∧ ¬Even n
⊢ a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n
state_after: no goals
tactic: simp [hn, (hn.1.strictMono_pow (R := R)).injective.eq_iff]
Theorem: frequently_frequently_nhds
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
p : X → Prop
⊢ (∃ᶠ (x' : X) in 𝓝 x, ∃ᶠ (x'' : X) in 𝓝 x', p x'') ↔ ∃ᶠ (x : X) in 𝓝 x, p x
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
p : X → Prop
⊢ (¬∃ᶠ (x' : X) in 𝓝 x, ∃ᶠ (x'' : X) in 𝓝 x', p x'') ↔ ¬∃ᶠ (x : X) in 𝓝 x, p x
tactic: rw [← not_iff_not]
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
p : X → Prop
⊢ (¬∃ᶠ (x' : X) in 𝓝 x, ∃ᶠ (x'' : X) in 𝓝 x', p x'') ↔ ¬∃ᶠ (x : X) in 𝓝 x, p x
state_after: no goals
tactic: simp only [not_frequently, eventually_eventually_nhds]
Theorem: lp.eq_zero_iff_coeFn_eq_zero
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : ↥(lp E p)
⊢ f = 0 ↔ ↑f = 0
state_after: no goals
tactic: rw [lp.ext_iff, coeFn_zero]
Theorem: Profinite.NobelingProof.GoodProducts.linearIndependentAux
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
μ : Ordinal.{u}
⊢ P I μ
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
⊢ LinearIndependent ℤ (eval C)
tactic: refine Ordinal.limitRecOn μ P0 (fun o h ho C hC hsC ↦ ?_)
      (fun o ho h ↦ (GoodProducts.Plimit o ho (fun o' ho' ↦ (h o' ho'))))
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
ho' : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (eval C)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
ho' : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (SumEval C ho')
tactic: rw [linearIndependent_iff_sum C hsC ho']
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
ho' : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent ℤ (SumEval C ho')
state_after: case refine_1
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
ho' : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent (ι := ↑(GoodProducts (π C fun x => ord I x < o))) ℤ (eval (π C fun x => ord I x < o))

case refine_2
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C✝ : Set (I → Bool)
μ o : Ordinal.{u}
h : P I o
ho : Order.succ o ≤ Ordinal.type fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
hsC : contained C (Order.succ o)
ho' : o < Ordinal.type fun x x_1 => x < x_1
⊢ LinearIndependent (ι := ↑(MaxProducts C ho')) ℤ
    (⇑(ShortComplex.mk (ModuleCat.ofHom (πs C o)) (ModuleCat.ofHom (Linear_CC' C hsC ho')) ⋯).g ∘
      SumEval C ho' ∘ Sum.inr)
tactic: refine ModuleCat.linearIndependent_leftExact (succ_exact C hC hsC ho') ?_ ?_ (succ_mono C o)
    (square_commutes C ho')