tasksource/leandojo huggingface dataset:
Theorem: Ideal.radical_eq_jacobson_iff_radical_quotient_eq_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: have hf : Function.Surjective (Ideal.Quotient.mk I) := Submodule.Quotient.mk_surjective I
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ radical I = jacobson I ↔ radical ⊥ = jacobson ⊥

tactic: constructor
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ radical I = jacobson I ↔ radical ⊥ = jacobson ⊥

tactic: intro h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ radical I = jacobson I → radical ⊥ = jacobson ⊥

tactic: have := congr_arg (map (Ideal.Quotient.mk I)) h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical I = jacobson I
⊢ radical ⊥ = jacobson ⊥

tactic: rw [map_radical_of_surjective hf (le_of_eq mk_ker),
  map_jacobson_of_surjective hf (le_of_eq mk_ker)] at this
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical I = jacobson I
this : map (Quotient.mk I) (radical I) = map (Quotient.mk I) (jacobson I)
⊢ radical ⊥ = jacobson ⊥

tactic: simpa using this
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical I = jacobson I
this : radical (map (Quotient.mk I) I) = jacobson (map (Quotient.mk I) I)
⊢ radical ⊥ = jacobson ⊥

tactic: intro h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ radical ⊥ = jacobson ⊥ → radical I = jacobson I

tactic: have := congr_arg (comap (Ideal.Quotient.mk I)) h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical ⊥ = jacobson ⊥
⊢ radical I = jacobson I

tactic: rw [comap_radical, comap_jacobson_of_surjective hf,
  ← RingHom.ker_eq_comap_bot (Ideal.Quotient.mk I)] at this
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical ⊥ = jacobson ⊥
this : comap (Quotient.mk I) (radical ⊥) = comap (Quotient.mk I) (jacobson ⊥)
⊢ radical I = jacobson I

tactic: simpa using this
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : radical ⊥ = jacobson ⊥
this : radical (RingHom.ker (Quotient.mk I)) = jacobson (RingHom.ker (Quotient.mk I))
⊢ radical I = jacobson I
Theorem: IntermediateField.AdjoinSimple.isIntegral_gen
File: Mathlib/FieldTheory/Adjoin.lean

tactic: conv_rhs => rw [← AdjoinSimple.algebraMap_gen F α]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
⊢ IsIntegral F (gen F α) ↔ IsIntegral F α

tactic: rw [isIntegral_algebraMap_iff (algebraMap F⟮α⟯ E).injective]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
⊢ IsIntegral F (gen F α) ↔ IsIntegral F (↑(algebraMap { x // x ∈ F⟮α⟯ } E) (gen F α))
Theorem: irrational_sqrt_two
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa using Nat.prime_two.irrational_sqrt
state_before: ⊢ Irrational (Real.sqrt 2)
Theorem: convexJoin_empty_left
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp [convexJoin]
state_before: ι : Sort ?u.16420
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
t : Set E
⊢ convexJoin 𝕜 ∅ t = ∅
Theorem: Ordinal.nfp_mul_one
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp, ← sup_opow_nat]
state_before: a : Ordinal
ha : 0 < a
⊢ nfp (fun x => a * x) 1 = a ^ ω

tactic: dsimp
state_before: a : Ordinal
ha : 0 < a
⊢ (fun a_1 => sup fun n => ((fun x => a * x)^[n]) a_1) 1 = sup fun n => a ^ ↑n

tactic: congr
state_before: a : Ordinal
ha : 0 < a
⊢ (sup fun n => ((fun x => a * x)^[n]) 1) = sup fun n => a ^ ↑n

tactic: funext n
state_before: case e_f
a : Ordinal
ha : 0 < a
⊢ (fun n => ((fun x => a * x)^[n]) 1) = fun n => a ^ ↑n

tactic: induction' n with n hn
state_before: case e_f.h
a : Ordinal
ha : 0 < a
n : ℕ
⊢ ((fun x => a * x)^[n]) 1 = a ^ ↑n

tactic: nth_rw 2 [Nat.succ_eq_one_add]
state_before: case e_f.h.succ
a : Ordinal
ha : 0 < a
n : ℕ
hn : ((fun x => a * x)^[n]) 1 = a ^ ↑n
⊢ ((fun x => a * x)^[Nat.succ n]) 1 = a ^ ↑(Nat.succ n)

tactic: rw [Nat.cast_add, Nat.cast_one, opow_add, opow_one, iterate_succ_apply', hn]
state_before: case e_f.h.succ
a : Ordinal
ha : 0 < a
n : ℕ
hn : ((fun x => a * x)^[n]) 1 = a ^ ↑n
⊢ ((fun x => a * x)^[Nat.succ n]) 1 = a ^ ↑(1 + n)

tactic: rw [Nat.cast_zero, opow_zero, iterate_zero_apply]
state_before: case e_f.h.zero
a : Ordinal
ha : 0 < a
⊢ ((fun x => a * x)^[Nat.zero]) 1 = a ^ ↑Nat.zero

tactic: exact ha
state_before: a : Ordinal
ha : 0 < a
⊢ 0 < a
Theorem: MeasureTheory.Measure.comapₗ_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comapₗ, dif_pos, liftLinear_apply _ hs, OuterMeasure.comap_apply]
state_before: α : Type u_2
β✝ : Type ?u.221666
γ : Type ?u.221669
δ : Type ?u.221672
ι : Type ?u.221675
R : Type ?u.221678
R' : Type ?u.221681
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ ↑↑(↑(comapₗ f) μ) s = ↑↑μ (f '' s)

tactic: exact ⟨hfi, hf⟩
state_before: case hc
α : Type u_2
β✝ : Type ?u.221666
γ : Type ?u.221669
δ : Type ?u.221672
ι : Type ?u.221675
R : Type ?u.221678
R' : Type ?u.221681
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)

case hc
α : Type u_2
β✝ : Type ?u.221666
γ : Type ?u.221669
δ : Type ?u.221672
ι : Type ?u.221675
R : Type ?u.221678
R' : Type ?u.221681
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
Theorem: RatFunc.natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree
File: Mathlib/FieldTheory/RatFunc.lean

tactic: apply natDegree_sub_eq_of_prod_eq (mul_ne_zero (num_ne_zero hx) hs)
  (mul_ne_zero hs x.denom_ne_zero) (num_ne_zero hx) x.denom_ne_zero
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
hx : x ≠ 0
s : K[X]
hs : s ≠ 0
⊢ ↑(natDegree (num x * s)) - ↑(natDegree (s * denom x)) = intDegree x

tactic: rw [mul_assoc]
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
hx : x ≠ 0
s : K[X]
hs : s ≠ 0
⊢ num x * s * denom x = num x * (s * denom x)
Theorem: Real.rpow_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← Complex.ofReal_inj, Complex.ofReal_cpow (rpow_nonneg_of_nonneg hx _),
    Complex.ofReal_cpow hx, Complex.ofReal_mul, Complex.cpow_mul, Complex.ofReal_cpow hx] <;>
  simp only [(Complex.ofReal_mul _ _).symm, (Complex.ofReal_log hx).symm, Complex.ofReal_im,
    neg_lt_zero, pi_pos, le_of_lt pi_pos]
state_before: x✝ y✝ z✝ x : ℝ
hx : 0 ≤ x
y z : ℝ
⊢ x ^ (y * z) = (x ^ y) ^ z
Theorem: MeasureTheory.Measure.dirac_bind
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.40352
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
⊢ bind m dirac = m

tactic: simp only [bind_apply hs measurable_dirac, dirac_apply' _ hs, lintegral_indicator 1 hs,
  Pi.one_apply, lintegral_one, restrict_apply, MeasurableSet.univ, univ_inter]
state_before: case h
α : Type u_1
β : Type ?u.40352
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
m : Measure α
s : Set α
hs : MeasurableSet s
⊢ ↑↑(bind m dirac) s = ↑↑m s
Theorem: Polynomial.eraseLead_coeff_natDegree
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: simp [eraseLead_coeff]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ coeff (eraseLead f) (natDegree f) = 0
Theorem: CategoryTheory.Limits.WidePullback.eq_lift_of_comp_eq
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: intro h1 h2
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ (∀ (j : J), g ≫ π arrows j = fs j) → g ≫ base arrows = f → g = lift f fs w

tactic: apply
  (limit.isLimit (WidePullbackShape.wideCospan B objs arrows)).uniq
    (WidePullbackShape.mkCone f fs <| w)
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ g = lift f fs w

tactic: rintro (_ | _)
state_before: case x
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ ∀ (j : WidePullbackShape J),
    g ≫ (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π.app j = (WidePullbackShape.mkCone f fs w).π.app j

tactic: apply h2
state_before: case x.none
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ g ≫ (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π.app none =
    (WidePullbackShape.mkCone f fs w).π.app none

tactic: apply h1
state_before: case x.some
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
val✝ : J
⊢ g ≫ (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π.app (some val✝) =
    (WidePullbackShape.mkCone f fs w).π.app (some val✝)
Theorem: associatedPrimes.nonempty
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

tactic: obtain ⟨x, hx⟩ := exists_ne (0 : M)
state_before: R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type ?u.65376
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
⊢ Set.Nonempty (associatedPrimes R M)

tactic: obtain ⟨P, hP, _⟩ := exists_le_isAssociatedPrime_of_isNoetherianRing R x hx
state_before: case intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type ?u.65376
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
⊢ Set.Nonempty (associatedPrimes R M)

tactic: exact ⟨P, hP⟩
state_before: case intro.intro.intro
R : Type u_1
inst✝⁶ : CommRing R
I J : Ideal R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type ?u.65376
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
f : M →ₗ[R] M'
inst✝¹ : IsNoetherianRing R
inst✝ : Nontrivial M
x : M
hx : x ≠ 0
P : Ideal R
hP : IsAssociatedPrime P M
right✝ : Submodule.annihilator (Submodule.span R {x}) ≤ P
⊢ Set.Nonempty (associatedPrimes R M)
Theorem: mul_singleton_mem_nhds
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp only [← iUnion_op_smul_set, mem_singleton_iff, iUnion_iUnion_eq_left]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
a b : α
h : s ∈ 𝓝 b
⊢ s * {a} ∈ 𝓝 (b * a)

tactic: exact smul_mem_nhds _ h
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
a b : α
h : s ∈ 𝓝 b
⊢ MulOpposite.op a • s ∈ 𝓝 (b * a)
Theorem: PNat.factorMultiset_le_iff'
File: Mathlib/Data/PNat/Factors.lean

tactic: let h := @factorMultiset_le_iff m v.prod
state_before: m : ℕ+
v : PrimeMultiset
⊢ factorMultiset m ≤ v ↔ m ∣ PrimeMultiset.prod v

tactic: rw [v.factorMultiset_prod] at h
state_before: m : ℕ+
v : PrimeMultiset
h : factorMultiset m ≤ factorMultiset (PrimeMultiset.prod v) ↔ m ∣ PrimeMultiset.prod v := factorMultiset_le_iff
⊢ factorMultiset m ≤ v ↔ m ∣ PrimeMultiset.prod v

tactic: exact h
state_before: m : ℕ+
v : PrimeMultiset
h : factorMultiset m ≤ v ↔ m ∣ PrimeMultiset.prod v
⊢ factorMultiset m ≤ v ↔ m ∣ PrimeMultiset.prod v
Theorem: Complex.hasStrictDerivAt_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean

tactic: convert (hasStrictDerivAt_sin x).div (hasStrictDerivAt_cos x) h using 1
state_before: x : ℂ
h : cos x ≠ 0
⊢ HasStrictDerivAt tan (↑1 / cos x ^ 2) x

tactic: rw_mod_cast [← sin_sq_add_cos_sq x]
state_before: case h.e'_7
x : ℂ
h : cos x ≠ 0
⊢ ↑1 / cos x ^ 2 = (cos x * cos x - sin x * -sin x) / cos x ^ 2

tactic: ring
state_before: case h.e'_7
x : ℂ
h : ¬cos x = 0
⊢ (sin x ^ 2 + cos x ^ 2) / cos x ^ 2 = (cos x * cos x - sin x * -sin x) / cos x ^ 2
Theorem: abs_le_abs_of_nonneg
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rwa [abs_of_nonneg ha, abs_of_nonneg (ha.trans hab)]
state_before: α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : 0 ≤ a
hab : a ≤ b
⊢ abs a ≤ abs b
Theorem: TopologicalSpace.IsTopologicalBasis.isOpen_iff
File: Mathlib/Topology/Bases.lean

tactic: simp [isOpen_iff_mem_nhds, hb.mem_nhds_iff]
state_before: α : Type u
t : TopologicalSpace α
s : Set α
b : Set (Set α)
hb : IsTopologicalBasis b
⊢ IsOpen s ↔ ∀ (a : α), a ∈ s → ∃ t, t ∈ b ∧ a ∈ t ∧ t ⊆ s
Theorem: mul_inv
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.29828
G : Type ?u.29831
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
Theorem: WittVector.ghostFun_nat_cast
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: induction i <;>
  simp [*, Nat.unaryCast, ghostFun_zero, ghostFun_one, ghostFun_add, -Pi.coe_nat]
state_before: p : ℕ
R : Type u_1
S : Type ?u.681371
T : Type ?u.681374
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.681389
β : Type ?u.681392
x y : 𝕎 R
i : ℕ
⊢ WittVector.ghostFun (Nat.unaryCast i) = ↑i
Theorem: List.foldr_inf_eq_inf_toFinset
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← coe_fold_r, ← Multiset.fold_dedup_idem, inf_def, ← List.toFinset_coe, toFinset_val,
  Multiset.map_id]
state_before: F : Type ?u.129296
α : Type u_1
β : Type ?u.129302
γ : Type ?u.129305
ι : Type ?u.129308
κ : Type ?u.129311
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
s s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
l : List α
⊢ List.foldr (fun x x_1 => x ⊓ x_1) ⊤ l = inf (List.toFinset l) id

tactic: rfl
state_before: F : Type ?u.129296
α : Type u_1
β : Type ?u.129302
γ : Type ?u.129305
ι : Type ?u.129308
κ : Type ?u.129311
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
s s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
l : List α
⊢ Multiset.fold (fun x x_1 => x ⊓ x_1) ⊤ (dedup ↑l) = Multiset.inf (dedup ↑l)
Theorem: Complex.one_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rw [cpow_def]
state_before: x : ℂ
⊢ 1 ^ x = 1

tactic: split_ifs <;> simp_all [one_ne_zero]
state_before: x : ℂ
⊢ (if 1 = 0 then if x = 0 then 1 else 0 else exp (log 1 * x)) = 1
Theorem: Dfinsupp.single_smul
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [smul_apply, single_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
i✝ : ι
c : γ
x : β i✝
i : ι
⊢ ↑(single i✝ (c • x)) i = ↑(c • single i✝ x) i

tactic: split_ifs with h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
i✝ : ι
c : γ
x : β i✝
i : ι
⊢ (if h : i✝ = i then (_ : i✝ = i) ▸ (c • x) else 0) = c • if h : i✝ = i then (_ : i✝ = i) ▸ x else 0

tactic: cases h
state_before: case inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
i✝ : ι
c : γ
x : β i✝
i : ι
h : i✝ = i
⊢ (_ : i✝ = i) ▸ (c • x) = c • (_ : i✝ = i) ▸ x

tactic: rfl
state_before: case inl.refl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
i : ι
c : γ
x : β i
⊢ (_ : i = i) ▸ (c • x) = c • (_ : i = i) ▸ x

tactic: rw [smul_zero]
state_before: case inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
i✝ : ι
c : γ
x : β i✝
i : ι
h : ¬i✝ = i
⊢ 0 = c • 0
Theorem: linearIndependent_sUnion_of_directed
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [sUnion_eq_iUnion]
state_before: ι : Type u'
ι' : Type ?u.216784
R : Type u_2
K : Type ?u.216790
M : Type u_1
M' : Type ?u.216796
M'' : Type ?u.216799
V : Type u
V' : Type ?u.216804
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set (Set M)
hs : DirectedOn (fun x x_1 => x ⊆ x_1) s
h : ∀ (a : Set M), a ∈ s → LinearIndependent R Subtype.val
⊢ LinearIndependent R fun x => ↑x

tactic: exact linearIndependent_iUnion_of_directed hs.directed_val (by simpa using h)
state_before: ι : Type u'
ι' : Type ?u.216784
R : Type u_2
K : Type ?u.216790
M : Type u_1
M' : Type ?u.216796
M'' : Type ?u.216799
V : Type u
V' : Type ?u.216804
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set (Set M)
hs : DirectedOn (fun x x_1 => x ⊆ x_1) s
h : ∀ (a : Set M), a ∈ s → LinearIndependent R Subtype.val
⊢ LinearIndependent R fun x => ↑x

tactic: simpa using h
state_before: ι : Type u'
ι' : Type ?u.216784
R : Type u_2
K : Type ?u.216790
M : Type u_1
M' : Type ?u.216796
M'' : Type ?u.216799
V : Type u
V' : Type ?u.216804
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set (Set M)
hs : DirectedOn (fun x x_1 => x ⊆ x_1) s
h : ∀ (a : Set M), a ∈ s → LinearIndependent R Subtype.val
⊢ ∀ (i : ↑s), LinearIndependent R fun x => ↑x
Theorem: ENNReal.funMulInvSnorm_rpow
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: rw [funMulInvSnorm, mul_rpow_of_nonneg _ _ (le_of_lt hp0)]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 < p
f : α → ℝ≥0∞
a : α
⊢ funMulInvSnorm f p μ a ^ p = f a ^ p * (∫⁻ (c : α), f c ^ p ∂μ)⁻¹

tactic: suffices h_inv_rpow : ((∫⁻ c : α, f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = (∫⁻ c : α, f c ^ p ∂μ)⁻¹
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 < p
f : α → ℝ≥0∞
a : α
⊢ f a ^ p * ((∫⁻ (c : α), f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = f a ^ p * (∫⁻ (c : α), f c ^ p ∂μ)⁻¹

tactic: rw [inv_rpow, ← rpow_mul, one_div_mul_cancel hp0.ne', rpow_one]
state_before: case h_inv_rpow
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 < p
f : α → ℝ≥0∞
a : α
⊢ ((∫⁻ (c : α), f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = (∫⁻ (c : α), f c ^ p ∂μ)⁻¹

tactic: rw [h_inv_rpow]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 < p
f : α → ℝ≥0∞
a : α
h_inv_rpow : ((∫⁻ (c : α), f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = (∫⁻ (c : α), f c ^ p ∂μ)⁻¹
⊢ f a ^ p * ((∫⁻ (c : α), f c ^ p ∂μ) ^ (1 / p))⁻¹ ^ p = f a ^ p * (∫⁻ (c : α), f c ^ p ∂μ)⁻¹
Theorem: LieSubalgebra.ucs_eq_self_of_isCartanSubalgebra
File: Mathlib/Algebra/Lie/CartanSubalgebra.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
H✝ H : LieSubalgebra R L
inst✝ : IsCartanSubalgebra H
k : ℕ
⊢ LieSubmodule.ucs k (toLieSubmodule H) = toLieSubmodule H

tactic: simp
state_before: case zero
R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
H✝ H : LieSubalgebra R L
inst✝ : IsCartanSubalgebra H
⊢ LieSubmodule.ucs Nat.zero (toLieSubmodule H) = toLieSubmodule H

tactic: simp [ih]
state_before: case succ
R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
H✝ H : LieSubalgebra R L
inst✝ : IsCartanSubalgebra H
k : ℕ
ih : LieSubmodule.ucs k (toLieSubmodule H) = toLieSubmodule H
⊢ LieSubmodule.ucs (Nat.succ k) (toLieSubmodule H) = toLieSubmodule H
Theorem: hasFTaylorSeriesUpTo_top_iff
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← hasFTaylorSeriesUpToOn_univ_iff, hasFTaylorSeriesUpToOn_top_iff]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ HasFTaylorSeriesUpTo ⊤ f p ↔ ∀ (n : ℕ), HasFTaylorSeriesUpTo (↑n) f p
Theorem: HasSum.prod_mk
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp [HasSum, ← prod_mk_sum, Filter.Tendsto.prod_mk_nhds hf hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.796690
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : AddCommMonoid γ
inst✝ : TopologicalSpace γ
f : β → α
g : β → γ
a : α
b : γ
hf : HasSum f a
hg : HasSum g b
⊢ HasSum (fun x => (f x, g x)) (a, b)