tasksource/leandojo huggingface dataset:
Theorem: WithTop.top_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: rw [top_mul', if_neg h]
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
a : WithTop α
h : a ≠ 0
⊢ ⊤ * a = ⊤
Theorem: Subgroup.mem_closure_pair
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [← Set.singleton_union, Subgroup.closure_union, mem_sup]
state_before: G : Type ?u.699594
G' : Type ?u.699597
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.699606
inst✝² : AddGroup A
N : Type ?u.699612
inst✝¹ : Group N
C : Type u_1
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ z ∈ closure {x, y} ↔ ∃ m n, x ^ m * y ^ n = z

tactic: simp_rw [mem_closure_singleton, exists_exists_eq_and]
state_before: G : Type ?u.699594
G' : Type ?u.699597
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.699606
inst✝² : AddGroup A
N : Type ?u.699612
inst✝¹ : Group N
C : Type u_1
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ (∃ y_1, y_1 ∈ closure {x} ∧ ∃ z_1, z_1 ∈ closure {y} ∧ y_1 * z_1 = z) ↔ ∃ m n, x ^ m * y ^ n = z
Theorem: Set.preimage_mul_left_singleton
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_left', image_singleton]
state_before: F : Type ?u.127859
α : Type u_1
β : Type ?u.127865
γ : Type ?u.127868
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x x_1 => x * x_1) a ⁻¹' {b} = {a⁻¹ * b}
Theorem: eq_one_of_mul_right
File: Mathlib/Algebra/Group/Units.lean

tactic: rwa [mul_comm]
state_before: α : Type u
inst✝¹ : CommMonoid α
inst✝ : Subsingleton αˣ
a b : α
h : a * b = 1
⊢ b * a = 1
Theorem: BilinForm.toMatrix'_compLeft
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [BilinForm.compLeft, BilinForm.toMatrix'_comp, toMatrix'_id, Matrix.mul_one]
state_before: R : Type ?u.601714
M : Type ?u.601717
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type ?u.601753
M₁ : Type ?u.601756
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.602368
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.602555
M₃ : Type ?u.602558
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.603146
K : Type ?u.603149
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
o : Type ?u.604366
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
B : BilinForm R₂ (n → R₂)
f : (n → R₂) →ₗ[R₂] n → R₂
⊢ ↑toMatrix' (compLeft B f) = (↑LinearMap.toMatrix' f)ᵀ ⬝ ↑toMatrix' B
Theorem: LieModuleHom.le_ker_iff_map
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [ker, eq_bot_iff, LieSubmodule.map_le_iff_le_comap]
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
M' : LieSubmodule R L M
⊢ M' ≤ ker f ↔ LieSubmodule.map f M' = ⊥
Theorem: BilinForm.isOrtho_smul_left
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: dsimp only [IsOrtho]
state_before: R : Type ?u.773122
M : Type ?u.773125
inst✝²² : Semiring R
inst✝²¹ : AddCommMonoid M
inst✝²⁰ : Module R M
R₁ : Type ?u.773161
M₁ : Type ?u.773164
inst✝¹⁹ : Ring R₁
inst✝¹⁸ : AddCommGroup M₁
inst✝¹⁷ : Module R₁ M₁
R₂ : Type ?u.773773
M₂ : Type ?u.773776
inst✝¹⁶ : CommSemiring R₂
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R₂ M₂
R₃ : Type ?u.773963
M₃ : Type ?u.773966
inst✝¹³ : CommRing R₃
inst✝¹² : AddCommGroup M₃
inst✝¹¹ : Module R₃ M₃
V : Type ?u.774554
K : Type ?u.774557
inst✝¹⁰ : Field K
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.775771
M₂'' : Type ?u.775774
inst✝⁷ : AddCommMonoid M₂'
inst✝⁶ : AddCommMonoid M₂''
inst✝⁵ : Module R₂ M₂'
inst✝⁴ : Module R₂ M₂''
R₄ : Type u_1
M₄ : Type u_2
inst✝³ : Ring R₄
inst✝² : IsDomain R₄
inst✝¹ : AddCommGroup M₄
inst✝ : Module R₄ M₄
G : BilinForm R₄ M₄
x y : M₄
a : R₄
ha : a ≠ 0
⊢ IsOrtho G (a • x) y ↔ IsOrtho G x y

tactic: rw [smul_left, mul_eq_zero, or_iff_right ha]
state_before: R : Type ?u.773122
M : Type ?u.773125
inst✝²² : Semiring R
inst✝²¹ : AddCommMonoid M
inst✝²⁰ : Module R M
R₁ : Type ?u.773161
M₁ : Type ?u.773164
inst✝¹⁹ : Ring R₁
inst✝¹⁸ : AddCommGroup M₁
inst✝¹⁷ : Module R₁ M₁
R₂ : Type ?u.773773
M₂ : Type ?u.773776
inst✝¹⁶ : CommSemiring R₂
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R₂ M₂
R₃ : Type ?u.773963
M₃ : Type ?u.773966
inst✝¹³ : CommRing R₃
inst✝¹² : AddCommGroup M₃
inst✝¹¹ : Module R₃ M₃
V : Type ?u.774554
K : Type ?u.774557
inst✝¹⁰ : Field K
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.775771
M₂'' : Type ?u.775774
inst✝⁷ : AddCommMonoid M₂'
inst✝⁶ : AddCommMonoid M₂''
inst✝⁵ : Module R₂ M₂'
inst✝⁴ : Module R₂ M₂''
R₄ : Type u_1
M₄ : Type u_2
inst✝³ : Ring R₄
inst✝² : IsDomain R₄
inst✝¹ : AddCommGroup M₄
inst✝ : Module R₄ M₄
G : BilinForm R₄ M₄
x y : M₄
a : R₄
ha : a ≠ 0
⊢ bilin G (a • x) y = 0 ↔ bilin G x y = 0
Theorem: Finset.min'_eq_sorted_zero
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [length_sort]
state_before: α : Type ?u.14071
β : Type ?u.14074
inst✝ : LinearOrder α
s : Finset α
h : Finset.Nonempty s
⊢ 0 < List.length (sort (fun x x_1 => x ≤ x_1) s)

tactic: exact card_pos.2 h
state_before: α : Type ?u.14071
β : Type ?u.14074
inst✝ : LinearOrder α
s : Finset α
h : Finset.Nonempty s
⊢ 0 < card s
Theorem: Complex.sinh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sinh, exp_neg, (neg_div _ _).symm, add_mul]
state_before: x y : ℂ
⊢ sinh (-x) = -sinh x
Theorem: Finset.affineCombination_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [← AffineMap.linearMap_vsub, affineCombination_linear, vsub_eq_sub]
state_before: k : Type u_3
V : Type u_1
P : Type u_2
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type ?u.264224
s₂ : Finset ι₂
w₁ w₂ : ι → k
p : ι → P
⊢ ↑(affineCombination k s p) w₁ -ᵥ ↑(affineCombination k s p) w₂ = ↑(weightedVSub s p) (w₁ - w₂)
Theorem: Lagrange.sum_nodalWeight_mul_inv_sub_ne_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simpa only [Pi.one_apply, interpolate_one hvs hs, eval_one, mul_one] using
  (eval_interpolate_not_at_node 1 hx).symm
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hvs : Set.InjOn v ↑s
hx : ∀ (i : ι), i ∈ s → x ≠ v i
hs : Finset.Nonempty s
⊢ eval x (nodal s v) * ∑ i in s, nodalWeight s v i * (x - v i)⁻¹ = 1
Theorem: lowerSemicontinuous_iff_isClosed_preimage
File: Mathlib/Topology/Semicontinuous.lean

tactic: rw [lowerSemicontinuous_iff_isOpen_preimage]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type ?u.24491
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_2
inst✝ : LinearOrder γ
f : α → γ
⊢ LowerSemicontinuous f ↔ ∀ (y : γ), IsClosed (f ⁻¹' Iic y)

tactic: simp only [← isOpen_compl_iff, ← preimage_compl, compl_Iic]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type ?u.24491
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_2
inst✝ : LinearOrder γ
f : α → γ
⊢ (∀ (y : γ), IsOpen (f ⁻¹' Ioi y)) ↔ ∀ (y : γ), IsClosed (f ⁻¹' Iic y)
Theorem: CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_inv
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
r s t : Cone F
P : IsLimit s
Q : IsLimit t
⊢ ∀ (j : J), (lift Q r ≫ (conePointUniqueUpToIso P Q).inv) ≫ s.π.app j = r.π.app j
Theorem: BoxIntegral.TaggedPrepartition.mem_infPrepartition_comm
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: simp only [← mem_toPrepartition, infPrepartition_toPrepartition, inf_comm]
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
⊢ J ∈ infPrepartition π₁ π₂.toPrepartition ↔ J ∈ infPrepartition π₂ π₁.toPrepartition
Theorem: BoxIntegral.Prepartition.mem_restrict'
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp only [mem_restrict, ← Box.withBotCoe_inj, Box.coe_inf, Box.coe_coe]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
⊢ J₁ ∈ restrict π J ↔ ∃ J', J' ∈ π ∧ ↑J₁ = ↑J ∩ ↑J'
Theorem: Equiv.cast_trans
File: Mathlib/Logic/Equiv/Defs.lean

tactic: substs h h2
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α β γ : Sort u_1
h : α = β
h2 : β = γ
x : α
⊢ ↑((Equiv.cast h).trans (Equiv.cast h2)) x = ↑(Equiv.cast (_ : α = γ)) x

tactic: rfl
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Sort u_1
x : α
⊢ ↑((Equiv.cast (_ : α = α)).trans (Equiv.cast (_ : α = α))) x = ↑(Equiv.cast (_ : α = α)) x
Theorem: mul_self_eq_zero
File: Mathlib/Algebra/GroupWithZero/Defs.lean

tactic: simp
state_before: G₀ : Type u
M₀ : Type u_1
M₀' : Type ?u.12250
G₀' : Type ?u.12253
inst✝¹ : MulZeroClass M₀
inst✝ : NoZeroDivisors M₀
a b : M₀
⊢ a * a = 0 ↔ a = 0
Theorem: Finset.attach_image_val
File: Mathlib/Data/Finset/Image.lean

tactic: rw [image_val, attach_val, Multiset.attach_map_val, dedup_eq_self]
state_before: α : Type u_1
β : Type ?u.108664
γ : Type ?u.108667
inst✝¹ : DecidableEq β
f g : α → β
s✝ : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
s : Finset α
⊢ (image Subtype.val (attach s)).val = s.val
Theorem: IsROrC.div_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_assoc, sub_eq_add_neg, neg_mul, mul_neg, neg_neg, map_neg,
  isROrC_simps]
state_before: K : Type u_1
E : Type ?u.5548479
inst✝ : IsROrC K
z w : K
⊢ ↑re (z / w) = ↑re z * ↑re w / ↑normSq w + ↑im z * ↑im w / ↑normSq w
Theorem: Computation.exists_of_mem_map
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← bind_pure] at h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ map f s
⊢ ∃ a, a ∈ s ∧ f a = b

tactic: exact
  let ⟨a, as, fb⟩ := exists_of_mem_bind h
  ⟨a, as, mem_unique (ret_mem _) fb⟩
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Computation α
h : b ∈ bind s (pure ∘ f)
⊢ ∃ a, a ∈ s ∧ f a = b
Theorem: Finset.not_mem_sdiff_of_mem_right
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_sdiff, h, not_true, not_false_iff, and_false_iff]
state_before: α : Type u_1
β : Type ?u.223601
γ : Type ?u.223604
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ t
⊢ ¬a ∈ s \ t
Theorem: PythagoreanTriple.zero
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: simp only [PythagoreanTriple, MulZeroClass.zero_mul, zero_add]
state_before: ⊢ PythagoreanTriple 0 0 0
Theorem: AntilipschitzWith.comp
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: rw [ENNReal.coe_mul, mul_assoc]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
Kg : ℝ≥0
g : β → γ
hg : AntilipschitzWith Kg g
Kf : ℝ≥0
f : α → β
hf : AntilipschitzWith Kf f
x y : α
⊢ ↑Kf * (↑Kg * edist (g (f x)) (g (f y))) = ↑(Kf * Kg) * edist ((g ∘ f) x) ((g ∘ f) y)

tactic: rfl
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
Kg : ℝ≥0
g : β → γ
hg : AntilipschitzWith Kg g
Kf : ℝ≥0
f : α → β
hf : AntilipschitzWith Kf f
x y : α
⊢ ↑Kf * (↑Kg * edist (g (f x)) (g (f y))) = ↑Kf * (↑Kg * edist ((g ∘ f) x) ((g ∘ f) y))
Theorem: IsLocalization.map_smul
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [Algebra.smul_def, Algebra.smul_def, RingHom.map_mul, map_eq]
state_before: R : Type u_2
inst✝⁷ : CommSemiring R
M : Submonoid R
S : Type u_3
inst✝⁶ : CommSemiring S
inst✝⁵ : Algebra R S
P : Type u_4
inst✝⁴ : CommSemiring P
inst✝³ : IsLocalization M S
g : R →+* P
hg : ∀ (y : { x // x ∈ M }), IsUnit (↑g ↑y)
T : Submonoid P
Q : Type u_1
inst✝² : CommSemiring Q
hy : M ≤ Submonoid.comap g T
inst✝¹ : Algebra P Q
inst✝ : IsLocalization T Q
x : S
z : R
⊢ ↑(map Q g hy) (z • x) = ↑g z • ↑(map Q g hy) x
Theorem: Real.inner_le_Lp_mul_Lq_hasSum_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: lift f to ι → ℝ≥0 using hf
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
A B : ℝ
hA : 0 ≤ A
hB : 0 ≤ B
hf : ∀ (i : ι), 0 ≤ f i
hg : ∀ (i : ι), 0 ≤ g i
hf_sum : HasSum (fun i => f i ^ p) (A ^ p)
hg_sum : HasSum (fun i => g i ^ q) (B ^ q)
⊢ ∃ C, 0 ≤ C ∧ C ≤ A * B ∧ HasSum (fun i => f i * g i) C

tactic: lift g to ι → ℝ≥0 using hg
state_before: case intro
ι : Type u
s : Finset ι
g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
A B : ℝ
hA : 0 ≤ A
hB : 0 ≤ B
hg : ∀ (i : ι), 0 ≤ g i
hg_sum : HasSum (fun i => g i ^ q) (B ^ q)
f : ι → ℝ≥0
hf_sum : HasSum (fun i => (fun i => ↑(f i)) i ^ p) (A ^ p)
⊢ ∃ C, 0 ≤ C ∧ C ≤ A * B ∧ HasSum (fun i => (fun i => ↑(f i)) i * g i) C

tactic: lift A to ℝ≥0 using hA
state_before: case intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
A B : ℝ
hA : 0 ≤ A
hB : 0 ≤ B
f : ι → ℝ≥0
hf_sum : HasSum (fun i => (fun i => ↑(f i)) i ^ p) (A ^ p)
g : ι → ℝ≥0
hg_sum : HasSum (fun i => (fun i => ↑(g i)) i ^ q) (B ^ q)
⊢ ∃ C, 0 ≤ C ∧ C ≤ A * B ∧ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) C

tactic: lift B to ℝ≥0 using hB
state_before: case intro.intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
B : ℝ
hB : 0 ≤ B
f g : ι → ℝ≥0
hg_sum : HasSum (fun i => (fun i => ↑(g i)) i ^ q) (B ^ q)
A : ℝ≥0
hf_sum : HasSum (fun i => (fun i => ↑(f i)) i ^ p) (↑A ^ p)
⊢ ∃ C, 0 ≤ C ∧ C ≤ ↑A * B ∧ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) C

tactic: norm_cast at hf_sum hg_sum
state_before: case intro.intro.intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f g : ι → ℝ≥0
A : ℝ≥0
hf_sum : HasSum (fun i => (fun i => ↑(f i)) i ^ p) (↑A ^ p)
B : ℝ≥0
hg_sum : HasSum (fun i => (fun i => ↑(g i)) i ^ q) (↑B ^ q)
⊢ ∃ C, 0 ≤ C ∧ C ≤ ↑A * ↑B ∧ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) C

tactic: obtain ⟨C, hC, H⟩ := NNReal.inner_le_Lp_mul_Lq_hasSum hpq hf_sum hg_sum
state_before: case intro.intro.intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f g : ι → ℝ≥0
A B : ℝ≥0
hf_sum : HasSum (fun a => f a ^ p) (A ^ p)
hg_sum : HasSum (fun a => g a ^ q) (B ^ q)
⊢ ∃ C, 0 ≤ C ∧ C ≤ ↑A * ↑B ∧ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) C

tactic: refine' ⟨C, C.prop, hC, _⟩
state_before: case intro.intro.intro.intro.intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f g : ι → ℝ≥0
A B : ℝ≥0
hf_sum : HasSum (fun a => f a ^ p) (A ^ p)
hg_sum : HasSum (fun a => g a ^ q) (B ^ q)
C : ℝ≥0
hC : C ≤ A * B
H : HasSum (fun i => f i * g i) C
⊢ ∃ C, 0 ≤ C ∧ C ≤ ↑A * ↑B ∧ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) C

tactic: norm_cast
state_before: case intro.intro.intro.intro.intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f g : ι → ℝ≥0
A B : ℝ≥0
hf_sum : HasSum (fun a => f a ^ p) (A ^ p)
hg_sum : HasSum (fun a => g a ^ q) (B ^ q)
C : ℝ≥0
hC : C ≤ A * B
H : HasSum (fun i => f i * g i) C
⊢ HasSum (fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) ↑C
Theorem: neg_strictConcaveOn_iff
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [← neg_strictConvexOn_iff, neg_neg f]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.678489
α : Type ?u.678492
β : Type u_3
ι : Type ?u.678498
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedAddCommGroup β
inst✝¹ : SMul 𝕜 E
inst✝ : Module 𝕜 β
s : Set E
f g : E → β
⊢ StrictConcaveOn 𝕜 s (-f) ↔ StrictConvexOn 𝕜 s f
Theorem: MulChar.inv_apply
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: by_cases ha : IsUnit a
state_before: R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
⊢ ↑χ⁻¹ a = ↑χ (Ring.inverse a)

tactic: rw [inv_apply_eq_inv]
state_before: case pos
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
⊢ ↑χ⁻¹ a = ↑χ (Ring.inverse a)

tactic: have h := IsUnit.map χ ha
state_before: case pos
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
⊢ Ring.inverse (↑χ a) = ↑χ (Ring.inverse a)

tactic: apply IsUnit.mul_right_injective h
state_before: case pos
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
h : IsUnit (↑χ a)
⊢ Ring.inverse (↑χ a) = ↑χ (Ring.inverse a)

tactic: dsimp only
state_before: case pos.a
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
h : IsUnit (↑χ a)
⊢ (fun x x_1 => x * x_1) (↑χ a) (Ring.inverse (↑χ a)) = (fun x x_1 => x * x_1) (↑χ a) (↑χ (Ring.inverse a))

tactic: erw [Ring.mul_inverse_cancel _ h, ← map_mul, Ring.mul_inverse_cancel _ ha]
state_before: case pos.a
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
h : IsUnit (↑χ a)
⊢ ↑χ a * Ring.inverse (↑χ a) = ↑χ a * ↑χ (Ring.inverse a)

tactic: exact (MulChar.map_one χ).symm
state_before: case pos.a
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : IsUnit a
h : IsUnit (↑χ a)
⊢ 1 = ↑χ 1

tactic: revert ha
state_before: case neg
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
ha : ¬IsUnit a
⊢ ↑χ⁻¹ a = ↑χ (Ring.inverse a)

tactic: nontriviality R
state_before: case neg
R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
⊢ ¬IsUnit a → ↑χ⁻¹ a = ↑χ (Ring.inverse a)

tactic: intro ha
state_before: R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
✝ : Nontrivial R
⊢ ¬IsUnit a → ↑χ⁻¹ a = ↑χ (Ring.inverse a)

tactic: rw [map_nonunit _ ha, Ring.inverse_non_unit a ha, MulChar.map_zero χ]
state_before: R✝ : Type u
inst✝² : CommMonoid R✝
R' : Type v
inst✝¹ : CommMonoidWithZero R'
R : Type u
inst✝ : CommMonoidWithZero R
χ : MulChar R R'
a : R
✝ : Nontrivial R
ha : ¬IsUnit a
⊢ ↑χ⁻¹ a = ↑χ (Ring.inverse a)
Theorem: Real.cos_abs
File: Mathlib/Data/Complex/Exponential.lean

tactic: cases le_total x 0 <;> simp only [*, _root_.abs_of_nonneg, abs_of_nonpos, cos_neg]
state_before: x y : ℝ
⊢ cos (abs' x) = cos x
Theorem: MeasureTheory.SimpleFunc.piecewise_univ
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.39189
δ : Type ?u.39192
inst✝ : MeasurableSpace α
f g : α →ₛ β
⊢ ↑(piecewise univ (_ : MeasurableSet univ) f g) = ↑f

tactic: convert Set.piecewise_univ f g
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.39189
δ : Type ?u.39192
inst✝ : MeasurableSpace α
f g : α →ₛ β
⊢ Set.piecewise univ ↑f ↑g = ↑f
Theorem: accPt_iff_frequently
File: Mathlib/Topology/Basic.lean

tactic: simp [acc_principal_iff_cluster, clusterPt_principal_iff_frequently, and_comm]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
C : Set α
⊢ AccPt x (𝓟 C) ↔ ∃ᶠ (y : α) in 𝓝 x, y ≠ x ∧ y ∈ C
Theorem: Nat.sub_eq_of_eq_add
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [h, Nat.add_sub_cancel]
state_before: a b c : Nat
h : a = c + b
⊢ a - b = c
Theorem: SimpleGraph.exists_maximal_degree_vertex
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: obtain ⟨t, ht⟩ := max_of_nonempty (univ_nonempty.image fun v => G.degree v)
state_before: ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
⊢ ∃ v, maxDegree G = degree G v

tactic: have ht₂ := mem_of_max ht
state_before: case intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
t : ℕ
ht : Finset.max (image (fun v => degree G v) univ) = ↑t
⊢ ∃ v, maxDegree G = degree G v

tactic: simp only [mem_image, mem_univ, exists_prop_of_true] at ht₂
state_before: case intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
t : ℕ
ht : Finset.max (image (fun v => degree G v) univ) = ↑t
ht₂ : t ∈ image (fun v => degree G v) univ
⊢ ∃ v, maxDegree G = degree G v

tactic: rcases ht₂ with ⟨v, _, rfl⟩
state_before: case intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
t : ℕ
ht : Finset.max (image (fun v => degree G v) univ) = ↑t
ht₂ : ∃ a, True ∧ degree G a = t
⊢ ∃ v, maxDegree G = degree G v

tactic: refine' ⟨v, _⟩
state_before: case intro.intro.intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
left✝ : True
ht : Finset.max (image (fun v => degree G v) univ) = ↑(degree G v)
⊢ ∃ v, maxDegree G = degree G v

tactic: rw [maxDegree, ht]
state_before: case intro.intro.intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
left✝ : True
ht : Finset.max (image (fun v => degree G v) univ) = ↑(degree G v)
⊢ maxDegree G = degree G v

tactic: rfl
state_before: case intro.intro.intro
ι : Sort ?u.292636
𝕜 : Type ?u.292639
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
v : V
left✝ : True
ht : Finset.max (image (fun v => degree G v) univ) = ↑(degree G v)
⊢ Option.getD (↑(degree G v)) 0 = degree G v
Theorem: Bool.or_comm
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b : Bool), (a || b) = (b || a)
Theorem: Colex.hom_le_iff
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [le_iff_le_iff_lt_iff_lt, hom_lt_iff h₁]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
h₁ : StrictMono f
A B : Finset α
⊢ toColex (image f A) ≤ toColex (image f B) ↔ toColex A ≤ toColex B
Theorem: Subgroup.normal_mul
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: rw [← set_mul_normal_comm, sup_comm, mul_normal]
state_before: α : Type ?u.32325
G : Type u_1
A : Type ?u.32331
S : Type ?u.32334
inst✝² : Group G
inst✝¹ : AddGroup A
s : Set G
N H : Subgroup G
inst✝ : Normal N
⊢ ↑(N ⊔ H) = ↑N * ↑H
Theorem: Rat.uniformSpace_eq
File: Mathlib/Topology/UniformSpace/CompareReals.lean

tactic: ext s
state_before: ⊢ AbsoluteValue.uniformSpace AbsoluteValue.abs = PseudoMetricSpace.toUniformSpace

tactic: rw [(AbsoluteValue.hasBasis_uniformity _).mem_iff, Metric.uniformity_basis_dist_rat.mem_iff]
state_before: case a.a
s : Set (ℚ × ℚ)
⊢ s ∈ uniformity ℚ ↔ s ∈ uniformity ℚ

tactic: simp only [Rat.dist_eq, AbsoluteValue.abs_apply, ← Rat.cast_sub, ← Rat.cast_abs, Rat.cast_lt,
  abs_sub_comm]
state_before: case a.a
s : Set (ℚ × ℚ)
⊢ (∃ i, 0 < i ∧ {p | ↑AbsoluteValue.abs (p.snd - p.fst) < i} ⊆ s) ↔ ∃ i, 0 < i ∧ {p | dist p.fst p.snd < ↑i} ⊆ s