tasksource/leandojo huggingface dataset:
Theorem: Cycle.lists_nil
File: Mathlib/Data/List/Cycle.lean

tactic: rw [nil, lists_coe, cyclicPermutations_nil]
state_before: α : Type u_1
⊢ lists nil = ↑[[]]
Theorem: not_isRightRegular_zero_iff
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rw [nontrivial_iff, not_iff_comm, isRightRegular_zero_iff_subsingleton, subsingleton_iff]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ ¬IsRightRegular 0 ↔ Nontrivial R

tactic: push_neg
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (¬∃ x y, x ≠ y) ↔ ∀ (x y : R), x = y

tactic: exact Iff.rfl
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (∀ (x y : R), x = y) ↔ ∀ (x y : R), x = y
Theorem: Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_le, ← not_le, not_iff_not, cos_nonneg_iff_abs_toReal_le_pi_div_two]
state_before: θ : Angle
⊢ cos θ < 0 ↔ π / 2 < abs (toReal θ)
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_eq_mass_mul
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: nth_rw 1 [μ.self_eq_mass_smul_normalize]
state_before: Ω : Type u_1
inst✝¹ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ testAgainstNN μ f = mass μ * testAgainstNN (ProbabilityMeasure.toFiniteMeasure (normalize μ)) f

tactic: rw [μ.normalize.toFiniteMeasure.smul_testAgainstNN_apply μ.mass f, smul_eq_mul]
state_before: Ω : Type u_1
inst✝¹ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ testAgainstNN (mass μ • ProbabilityMeasure.toFiniteMeasure (normalize μ)) f =
    mass μ * testAgainstNN (ProbabilityMeasure.toFiniteMeasure (normalize μ)) f
Theorem: LowerSet.prod_eq_bot
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [SetLike.ext'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.188893
ι : Sort ?u.188896
κ : ι → Sort ?u.188901
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥

tactic: exact prod_eq_empty_iff
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.188893
ι : Sort ?u.188896
κ : ι → Sort ?u.188901
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ ↑(s ×ˢ t) = ↑⊥ ↔ ↑s = ↑⊥ ∨ ↑t = ↑⊥
Theorem: Nat.sqrt_eq_zero
File: Mathlib/Data/Nat/Sqrt.lean

tactic: rw [h]
state_before: n : ℕ
h : sqrt n = 0
⊢ sqrt n < 1

tactic: decide
state_before: n : ℕ
h : sqrt n = 0
⊢ 0 < 1

tactic: rintro rfl
state_before: n : ℕ
⊢ n = 0 → sqrt n = 0

tactic: simp
state_before: ⊢ sqrt 0 = 0
Theorem: Subgroup.zpowers_eq_closure
File: Mathlib/GroupTheory/Subgroup/ZPowers.lean

tactic: ext
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.4059
inst✝¹ : AddGroup A
N : Type ?u.4065
inst✝ : Group N
g : G
⊢ zpowers g = closure {g}

tactic: exact mem_closure_singleton.symm
state_before: case h
G : Type u_1
inst✝² : Group G
A : Type ?u.4059
inst✝¹ : AddGroup A
N : Type ?u.4065
inst✝ : Group N
g x✝ : G
⊢ x✝ ∈ zpowers g ↔ x✝ ∈ closure {g}
Theorem: LinearMap.isOrtho_zero_left
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: dsimp only [IsOrtho]
state_before: R : Type u_2
R₁ : Type u_1
R₂ : Type u_5
R₃ : Type ?u.6685
M : Type ?u.6688
M₁ : Type u_3
M₂ : Type u_4
Mₗ₁ : Type ?u.6697
Mₗ₁' : Type ?u.6700
Mₗ₂ : Type ?u.6703
Mₗ₂' : Type ?u.6706
K : Type ?u.6709
K₁ : Type ?u.6712
K₂ : Type ?u.6715
V : Type ?u.6718
V₁ : Type ?u.6721
V₂ : Type ?u.6724
n : Type ?u.6727
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : CommSemiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
I₁ : R₁ →+* R
I₂ : R₂ →+* R
I₁' : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] R
x : M₂
⊢ IsOrtho B 0 x

tactic: rw [map_zero B, zero_apply]
state_before: R : Type u_2
R₁ : Type u_1
R₂ : Type u_5
R₃ : Type ?u.6685
M : Type ?u.6688
M₁ : Type u_3
M₂ : Type u_4
Mₗ₁ : Type ?u.6697
Mₗ₁' : Type ?u.6700
Mₗ₂ : Type ?u.6703
Mₗ₂' : Type ?u.6706
K : Type ?u.6709
K₁ : Type ?u.6712
K₂ : Type ?u.6715
V : Type ?u.6718
V₁ : Type ?u.6721
V₂ : Type ?u.6724
n : Type ?u.6727
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : CommSemiring R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
I₁ : R₁ →+* R
I₂ : R₂ →+* R
I₁' : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] R
x : M₂
⊢ ↑(↑B 0) x = 0
Theorem: Hyperreal.neg_lt_of_tendsto_zero_of_pos
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [neg_zero] at hg
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r✝ : ℝ
hr : 0 < r✝
hg : Tendsto (fun x => -f x) atTop (𝓝 (-0))
⊢ -ofSeq f < ↑r✝

tactic: exact lt_of_tendsto_zero_of_pos hg hr
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r✝ : ℝ
hr : 0 < r✝
hg : Tendsto (fun x => -f x) atTop (𝓝 0)
⊢ -ofSeq f < ↑r✝
Theorem: ClosedEmbedding.isCompact_preimage
File: Mathlib/Topology/SubsetProperties.lean

tactic: replace hK := hK.inter_right hf.closed_range
state_before: α : Type u
β : Type v
ι : Type ?u.93816
π : ι → Type ?u.93821
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : α → β
hf : ClosedEmbedding f
K : Set β
hK : IsCompact K
⊢ IsCompact (f ⁻¹' K)

tactic: rwa [← hf.toInducing.isCompact_iff, image_preimage_eq_inter_range]
state_before: α : Type u
β : Type v
ι : Type ?u.93816
π : ι → Type ?u.93821
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : α → β
hf : ClosedEmbedding f
K : Set β
hK : IsCompact (K ∩ range f)
⊢ IsCompact (f ⁻¹' K)
Theorem: CategoryTheory.Equivalence.cancel_counitInv_right_assoc'
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: simp only [← Category.assoc, cancel_mono]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
e : C ≌ D
W X X' Y Y' Z : D
f : W ⟶ X
g : X ⟶ Y
h : Y ⟶ Z
f' : W ⟶ X'
g' : X' ⟶ Y'
h' : Y' ⟶ Z
⊢ f ≫ g ≫ h ≫ (counitInv e).app Z = f' ≫ g' ≫ h' ≫ (counitInv e).app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h'
Theorem: Submodule.ker_inr
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [ker, ← prod_bot, prod_comap_inr]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.318044
M₆ : Type ?u.318047
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ker (inr R M M₂) = ⊥
Theorem: Matrix.single_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: have : ∀ (j) (_ : j ≠ i), Pi.single (f := fun _ => α) i x j * v j = 0 := fun j hij => by
  simp [Pi.single_eq_of_ne hij]
state_before: l : Type ?u.160745
m : Type u_1
n : Type ?u.160751
o : Type ?u.160754
m' : o → Type ?u.160759
n' : o → Type ?u.160764
R : Type ?u.160767
S : Type ?u.160770
α : Type v
β : Type w
γ : Type ?u.160777
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i : m
⊢ Pi.single i x ⬝ᵥ v = x * v i

tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
state_before: l : Type ?u.160745
m : Type u_1
n : Type ?u.160751
o : Type ?u.160754
m' : o → Type ?u.160759
n' : o → Type ?u.160764
R : Type ?u.160767
S : Type ?u.160770
α : Type v
β : Type w
γ : Type ?u.160777
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i : m
this : ∀ (j : m), j ≠ i → Pi.single i x j * v j = 0
⊢ Pi.single i x ⬝ᵥ v = x * v i

tactic: simp [Pi.single_eq_of_ne hij]
state_before: l : Type ?u.160745
m : Type u_1
n : Type ?u.160751
o : Type ?u.160754
m' : o → Type ?u.160759
n' : o → Type ?u.160764
R : Type ?u.160767
S : Type ?u.160770
α : Type v
β : Type w
γ : Type ?u.160777
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i j : m
hij : j ≠ i
⊢ Pi.single i x j * v j = 0
Theorem: OreLocalization.numeratorHom_inj
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rw [numeratorHom_apply, numeratorHom_apply, oreDiv_eq_iff] at h
state_before: R : Type u_1
inst✝¹ : Ring R
S : Submonoid R
inst✝ : OreSet S
hS : S ≤ R⁰
r₁ r₂ : R
h : ↑numeratorHom r₁ = ↑numeratorHom r₂
⊢ r₁ = r₂

tactic: rcases h with ⟨u, v, h₁, h₂⟩
state_before: R : Type u_1
inst✝¹ : Ring R
S : Submonoid R
inst✝ : OreSet S
hS : S ≤ R⁰
r₁ r₂ : R
h : ∃ u v, r₂ * ↑u = r₁ * v ∧ ↑1 * ↑u = ↑1 * v
⊢ r₁ = r₂

tactic: simp only [S.coe_one, one_mul] at h₂
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : Ring R
S : Submonoid R
inst✝ : OreSet S
hS : S ≤ R⁰
r₁ r₂ : R
u : { x // x ∈ S }
v : R
h₁ : r₂ * ↑u = r₁ * v
h₂ : ↑1 * ↑u = ↑1 * v
⊢ r₁ = r₂

tactic: rwa [← h₂, mul_cancel_right_mem_nonZeroDivisors (hS (SetLike.coe_mem u)), eq_comm] at h₁
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : Ring R
S : Submonoid R
inst✝ : OreSet S
hS : S ≤ R⁰
r₁ r₂ : R
u : { x // x ∈ S }
v : R
h₁ : r₂ * ↑u = r₁ * v
h₂ : ↑u = v
⊢ r₁ = r₂
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_mono
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp only [← ENNReal.coe_le_coe, testAgainstNN_coe_eq]
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type ?u.49329
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ↑f ≤ ↑g
⊢ testAgainstNN μ f ≤ testAgainstNN μ g

tactic: exact lintegral_mono fun ω => ENNReal.coe_mono (f_le_g ω)
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type ?u.49329
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
f g : Ω →ᵇ ℝ≥0
f_le_g : ↑f ≤ ↑g
⊢ (∫⁻ (ω : Ω), ↑(↑f ω) ∂↑μ) ≤ ∫⁻ (ω : Ω), ↑(↑g ω) ∂↑μ
Theorem: Equiv.Perm.support_prod_of_pairwise_disjoint
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: induction' l with hd tl hl
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : List.Pairwise Disjoint l
⊢ support (List.prod l) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support l)

tactic: simp
state_before: case nil
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
h : List.Pairwise Disjoint []
⊢ support (List.prod []) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support [])

tactic: rw [List.pairwise_cons] at h
state_before: case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
hd : Perm α
tl : List (Perm α)
hl : List.Pairwise Disjoint tl → support (List.prod tl) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support tl)
h : List.Pairwise Disjoint (hd :: tl)
⊢ support (List.prod (hd :: tl)) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support (hd :: tl))

tactic: have : Disjoint hd tl.prod := disjoint_prod_right _ h.left
state_before: case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
hd : Perm α
tl : List (Perm α)
hl : List.Pairwise Disjoint tl → support (List.prod tl) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support tl)
h : (∀ (a' : Perm α), a' ∈ tl → Disjoint hd a') ∧ List.Pairwise Disjoint tl
⊢ support (List.prod (hd :: tl)) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support (hd :: tl))

tactic: simp [this.support_mul, hl h.right]
state_before: case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h✝ : List.Pairwise Disjoint l
hd : Perm α
tl : List (Perm α)
hl : List.Pairwise Disjoint tl → support (List.prod tl) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support tl)
h : (∀ (a' : Perm α), a' ∈ tl → Disjoint hd a') ∧ List.Pairwise Disjoint tl
this : Disjoint hd (List.prod tl)
⊢ support (List.prod (hd :: tl)) = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support (hd :: tl))
Theorem: ExistsUnique.intro₂
File: Mathlib/Logic/Basic.lean

tactic: simp only [exists_unique_iff_exists]
state_before: ι : Sort ?u.25148
α✝ : Sort ?u.25153
κ : ι → Sort ?u.25150
p✝ q✝ : α✝ → Prop
α : Sort u_1
p : α → Sort u_2
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
w : α
hp : p w
hq : q w hp
H : ∀ (y : α) (hy : p y), q y hy → y = w
⊢ ∃! x hx, q x hx

tactic: exact ExistsUnique.intro w ⟨hp, hq⟩ fun y ⟨hyp, hyq⟩ ↦ H y hyp hyq
state_before: ι : Sort ?u.25148
α✝ : Sort ?u.25153
κ : ι → Sort ?u.25150
p✝ q✝ : α✝ → Prop
α : Sort u_1
p : α → Sort u_2
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
w : α
hp : p w
hq : q w hp
H : ∀ (y : α) (hy : p y), q y hy → y = w
⊢ ∃! x, ∃ hx, q x hx
Theorem: List.Ico.eq_empty_iff
File: Mathlib/Data/List/Intervals.lean

tactic: rw [← length, h, List.length]
state_before: n m : ℕ
h : Ico n m = []
⊢ m - n = 0
Theorem: Finset.card_Ioi_eq_card_Ici_sub_one
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [Ici_eq_cons_Ioi, card_cons, add_tsub_cancel_right]
state_before: ι : Type ?u.116791
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderTop α
a : α
⊢ card (Ioi a) = card (Ici a) - 1
Theorem: LinearMap.detAux_def''
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: induction tb using Trunc.induction_on with
| h b => rw [detAux_def', det_toMatrix_eq_det_toMatrix b b']
state_before: R : Type ?u.143873
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.144464
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.145982
inst✝² : Fintype κ
ι' : Type u_1
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
tb : Trunc (Basis ι A M)
b' : Basis ι' A M
f : M →ₗ[A] M
⊢ ↑(detAux tb) f = det (↑(toMatrix b' b') f)

tactic: rw [detAux_def', det_toMatrix_eq_det_toMatrix b b']
state_before: case h
R : Type ?u.143873
inst✝¹¹ : CommRing R
M : Type u_2
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
M' : Type ?u.144464
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
ι : Type u_4
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M
A : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Module A M
κ : Type ?u.145982
inst✝² : Fintype κ
ι' : Type u_1
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
b' : Basis ι' A M
f : M →ₗ[A] M
b : Basis ι A M
⊢ ↑(detAux (Trunc.mk b)) f = det (↑(toMatrix b' b') f)
Theorem: ENNReal.ofReal_sub
File: Mathlib/Data/Real/ENNReal.lean

tactic: obtain h | h := le_total p q
state_before: α : Type ?u.808531
β : Type ?u.808534
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q

tactic: refine' ENNReal.eq_sub_of_add_eq ofReal_ne_top _
state_before: case inr
α : Type ?u.808531
β : Type ?u.808534
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q

tactic: rw [← ofReal_add (sub_nonneg_of_le h) hq, sub_add_cancel]
state_before: case inr
α : Type ?u.808531
β : Type ?u.808534
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) + ENNReal.ofReal q = ENNReal.ofReal p

tactic: rw [ofReal_of_nonpos (sub_nonpos_of_le h), tsub_eq_zero_of_le (ofReal_le_ofReal h)]
state_before: case inl
α : Type ?u.808531
β : Type ?u.808534
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : p ≤ q
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
Theorem: MeasureTheory.SimpleFunc.measure_lt_top_of_memℒp_indicator
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: have : Function.support (const α c) = Set.univ := Function.support_const hc
state_before: α : Type u_2
β : Type ?u.1445144
ι : Type ?u.1445147
E : Type u_1
F : Type ?u.1445153
𝕜 : Type ?u.1445156
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
hp_pos : p ≠ 0
hp_ne_top : p ≠ ⊤
c : E
hc : c ≠ 0
s : Set α
hs : MeasurableSet s
hcs : Memℒp (↑(piecewise s hs (const α c) (const α 0))) p
⊢ ↑↑μ s < ⊤

tactic: simpa only [memℒp_iff_finMeasSupp hp_pos hp_ne_top, finMeasSupp_iff_support,
  support_indicator, Set.inter_univ, this] using hcs
state_before: α : Type u_2
β : Type ?u.1445144
ι : Type ?u.1445147
E : Type u_1
F : Type ?u.1445153
𝕜 : Type ?u.1445156
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ : Measure α
p : ℝ≥0∞
hp_pos : p ≠ 0
hp_ne_top : p ≠ ⊤
c : E
hc : c ≠ 0
s : Set α
hs : MeasurableSet s
hcs : Memℒp (↑(piecewise s hs (const α c) (const α 0))) p
this : support ↑(const α c) = Set.univ
⊢ ↑↑μ s < ⊤
Theorem: PrimeSpectrum.isClosed_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [isClosed_iff_zeroLocus]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set R
⊢ IsClosed (zeroLocus s)

tactic: exact ⟨s, rfl⟩
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set R
⊢ ∃ s_1, zeroLocus s = zeroLocus s_1
Theorem: div_inv_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.28599
G : Type ?u.28602
inst✝ : DivisionMonoid α
a b c : α
⊢ a / b⁻¹ = a * b
Theorem: Submodule.map_mem_span_algebraMap_image
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: rw [span_algebraMap_image_of_tower, mem_map]
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring S✝
inst✝¹⁰ : AddCommMonoid A
inst✝⁹ : Algebra R S✝
inst✝⁸ : Module S✝ A
inst✝⁷ : Module R A
inst✝⁶ : IsScalarTower R S✝ A
S : Type u_1
T : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Semiring T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
x : S
a : Set S
hx : x ∈ span R a
⊢ ↑(algebraMap S T) x ∈ span R (↑(algebraMap S T) '' a)

tactic: exact ⟨x, hx, rfl⟩
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring S✝
inst✝¹⁰ : AddCommMonoid A
inst✝⁹ : Algebra R S✝
inst✝⁸ : Module S✝ A
inst✝⁷ : Module R A
inst✝⁶ : IsScalarTower R S✝ A
S : Type u_1
T : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Semiring T
inst✝³ : Algebra R S
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
x : S
a : Set S
hx : x ∈ span R a
⊢ ∃ y, y ∈ span R a ∧ ↑(↑R (Algebra.linearMap S T)) y = ↑(algebraMap S T) x
Theorem: Nat.Linear.Poly.denote_toExpr_go
File: src/lean/Init/Data/Nat/Linear.lean

tactic: induction p generalizing e with
| nil => simp [toExpr.go, Poly.denote]
| cons kv p ih => cases kv; simp [toExpr.go, ih, Expr.denote, Poly.denote]
state_before: ctx : Context
e : Expr
p : Poly
⊢ Expr.denote ctx (toExpr.go e p) = Expr.denote ctx e + denote ctx p

tactic: simp [toExpr.go, Poly.denote]
state_before: case nil
ctx : Context
e : Expr
⊢ Expr.denote ctx (toExpr.go e []) = Expr.denote ctx e + denote ctx []

tactic: cases kv
state_before: case cons
ctx : Context
kv : Nat × Var
p : List (Nat × Var)
ih : ∀ (e : Expr), Expr.denote ctx (toExpr.go e p) = Expr.denote ctx e + denote ctx p
e : Expr
⊢ Expr.denote ctx (toExpr.go e (kv :: p)) = Expr.denote ctx e + denote ctx (kv :: p)

tactic: simp [toExpr.go, ih, Expr.denote, Poly.denote]
state_before: case cons.mk
ctx : Context
p : List (Nat × Var)
ih : ∀ (e : Expr), Expr.denote ctx (toExpr.go e p) = Expr.denote ctx e + denote ctx p
e : Expr
fst✝ : Nat
snd✝ : Var
⊢ Expr.denote ctx (toExpr.go e ((fst✝, snd✝) :: p)) = Expr.denote ctx e + denote ctx ((fst✝, snd✝) :: p)
Theorem: Convex.affine_image
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.240342
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
f : E →ᵃ[𝕜] F
hs : Convex 𝕜 s
⊢ Convex 𝕜 (↑f '' s)

tactic: exact (hs hx).affine_image _
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.240342
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
f : E →ᵃ[𝕜] F
hs : Convex 𝕜 s
x : E
hx : x ∈ s
⊢ StarConvex 𝕜 (↑f x) (↑f '' s)
Theorem: lowerCentralSeries_antitone
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: refine' antitone_nat_of_succ_le fun n x hx => _
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ Antitone (lowerCentralSeries G)

tactic: simp only [mem_lowerCentralSeries_succ_iff, exists_prop, mem_top, exists_true_left,
  true_and_iff] at hx
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
x : G
hx : x ∈ lowerCentralSeries G (n + 1)
⊢ x ∈ lowerCentralSeries G n

tactic: refine'
  closure_induction hx _ (Subgroup.one_mem _) (@Subgroup.mul_mem _ _ _) (@Subgroup.inv_mem _ _ _)
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
x : G
hx : x ∈ closure {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, p * q * p⁻¹ * q⁻¹ = x}
⊢ x ∈ lowerCentralSeries G n

tactic: rintro y ⟨z, hz, a, ha⟩
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
x : G
hx : x ∈ closure {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, p * q * p⁻¹ * q⁻¹ = x}
⊢ ∀ (x : G), x ∈ {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, p * q * p⁻¹ * q⁻¹ = x} → x ∈ lowerCentralSeries G n

tactic: rw [← ha, mul_assoc, mul_assoc, ← mul_assoc a z⁻¹ a⁻¹]
state_before: case intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
x : G
hx : x ∈ closure {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, p * q * p⁻¹ * q⁻¹ = x}
y z : G
hz : z ∈ lowerCentralSeries G n
a : G
ha : z * a * z⁻¹ * a⁻¹ = y
⊢ y ∈ lowerCentralSeries G n

tactic: exact mul_mem hz (Normal.conj_mem (lowerCentralSeries_normal n) z⁻¹ (inv_mem hz) a)
state_before: case intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
x : G
hx : x ∈ closure {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, p * q * p⁻¹ * q⁻¹ = x}
y z : G
hz : z ∈ lowerCentralSeries G n
a : G
ha : z * a * z⁻¹ * a⁻¹ = y
⊢ z * (a * z⁻¹ * a⁻¹) ∈ lowerCentralSeries G n
Theorem: Convex.combo_self
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [← add_smul, h, one_smul]
state_before: α : Type ?u.11520
R : Type u_1
k : Type ?u.11526
S : Type ?u.11529
M : Type u_2
M₂ : Type ?u.11535
M₃ : Type ?u.11538
ι : Type ?u.11541
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r s : R
x✝ y : M
a b : R
h : a + b = 1
x : M
⊢ a • x + b • x = x
Theorem: List.card_insert_of_not_mem
File: Mathlib/Data/List/Card.lean

tactic: simp [h]
state_before: α : Type u_1
β : Sort ?u.26060
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as : List α
h : ¬a ∈ as
⊢ card (List.insert a as) = card as + 1
Theorem: Finset.prod_preimage'
File: Mathlib/Data/Finset/Preimage.lean

tactic: haveI := Classical.decEq γ
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : CommMonoid β
f : α → γ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
⊢ ∏ x in preimage s f hf, g (f x) = ∏ x in filter (fun x => x ∈ Set.range f) s, g x

tactic: calc
  (∏ x in preimage s f hf, g (f x)) = ∏ x in image f (preimage s f hf), g x :=
    Eq.symm <| prod_image <| by simpa only [mem_preimage, InjOn] using hf
  _ = ∏ x in s.filter fun x => x ∈ Set.range f, g x := by rw [image_preimage]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : CommMonoid β
f : α → γ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
this : DecidableEq γ
⊢ ∏ x in preimage s f hf, g (f x) = ∏ x in filter (fun x => x ∈ Set.range f) s, g x

tactic: simpa only [mem_preimage, InjOn] using hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : CommMonoid β
f : α → γ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
this : DecidableEq γ
⊢ ∀ (x : α), x ∈ preimage s f hf → ∀ (y : α), y ∈ preimage s f hf → f x = f y → x = y

tactic: rw [image_preimage]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : CommMonoid β
f : α → γ
inst✝ : DecidablePred fun x => x ∈ Set.range f
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
this : DecidableEq γ
⊢ ∏ x in image f (preimage s f hf), g x = ∏ x in filter (fun x => x ∈ Set.range f) s, g x