tasksource/leandojo huggingface dataset:
Theorem: ENNReal.one_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 ≤ x
hz : 0 < z
⊢ 1 ≤ x ^ z

tactic: simp [top_rpow_of_pos hz]
state_before: case none
z : ℝ
hz : 0 < z
hx : 1 ≤ none
⊢ 1 ≤ none ^ z

tactic: simp only [one_le_coe_iff, some_eq_coe] at hx
state_before: case some
z : ℝ
hz : 0 < z
val✝ : ℝ≥0
hx : 1 ≤ Option.some val✝
⊢ 1 ≤ Option.some val✝ ^ z

tactic: simp [coe_rpow_of_nonneg _ (le_of_lt hz), NNReal.one_le_rpow hx (le_of_lt hz)]
state_before: case some
z : ℝ
hz : 0 < z
val✝ : ℝ≥0
hx : 1 ≤ val✝
⊢ 1 ≤ Option.some val✝ ^ z
Theorem: CategoryTheory.IsCoseparating.isCodetecting
File: Mathlib/CategoryTheory/Generator.lean

tactic: simpa only [← isDetecting_op_iff, ← isSeparating_op_iff] using IsSeparating.isDetecting
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : Balanced C
𝒢 : Set C
⊢ IsCoseparating 𝒢 → IsCodetecting 𝒢
Theorem: Turing.ToPartrec.Code.cons_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: f fs : Code
⊢ eval (cons f fs) = fun v => do
    let n ← eval f v
    let ns ← eval fs v
    pure (List.headI n :: ns)
Theorem: Quiver.Path.nil_comp
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: rw [comp_cons, nil_comp p]
state_before: V : Type u
inst✝ : Quiver V
a✝¹ b c d a x✝ b✝ : V
p : Path a b✝
a✝ : b✝ ⟶ x✝
⊢ comp nil (cons p a✝) = cons p a✝
Theorem: FiniteDimensional.nontrivial_of_finrank_eq_succ
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [hn]
state_before: K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < finrank (?m.96464 hn) V

tactic: exact n.succ_pos
state_before: K : Type u
V : Type v
inst✝⁶ : Ring K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : Nontrivial K
inst✝ : NoZeroSMulDivisors K V
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < Nat.succ n
Theorem: Computation.liftRel_pure
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [liftRel_pure_left]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
⊢ LiftRel R (pure a) (pure b) ↔ R a b

tactic: exact ⟨fun ⟨b', mb', ab'⟩ => by rwa [eq_of_pure_mem mb'] at ab', fun ab => ⟨_, ret_mem _, ab⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
⊢ (∃ b_1, b_1 ∈ pure b ∧ R a b_1) ↔ R a b

tactic: rwa [eq_of_pure_mem mb'] at ab'
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
x✝ : ∃ b_1, b_1 ∈ pure b ∧ R a b_1
b' : β
mb' : b' ∈ pure b
ab' : R a b'
⊢ R a b
Theorem: norm_iteratedFDerivWithin_eq_norm_iteratedDerivWithin
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: rw [iteratedDerivWithin_eq_equiv_comp, Function.comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_1
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.24509
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ ‖iteratedFDerivWithin 𝕜 n f s x‖ = ‖iteratedDerivWithin n f s x‖
Theorem: SymplecticGroup.inv_eq_symplectic_inv
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: simp only [Matrix.neg_mul, inv_left_mul_aux hA]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A✝ A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ (-J l R) ⬝ Aᵀ ⬝ J l R ⬝ A = 1
Theorem: List.doubleton_eq
File: Mathlib/Data/List/Basic.lean

tactic: rw [insert_neg, singleton_eq]
state_before: ι : Type ?u.7883
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ {x, y} = [x, y]

tactic: rwa [singleton_eq, mem_singleton]
state_before: ι : Type ?u.7883
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ ¬x ∈ {y}
Theorem: Matrix.toLinearMap₂'_comp
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp
state_before: R : Type u_3
R₁ : Type ?u.1177421
R₂ : Type ?u.1177424
M✝ : Type ?u.1177427
M₁ : Type ?u.1177430
M₂ : Type ?u.1177433
M₁' : Type ?u.1177436
M₂' : Type ?u.1177439
n : Type u_1
m : Type u_2
n' : Type u_4
m' : Type u_5
ι : Type ?u.1177454
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing R₁
inst✝⁸ : CommRing R₂
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
M : Matrix n m R
P : Matrix n n' R
Q : Matrix m m' R
⊢ ↑toMatrix₂' (compl₁₂ (↑toLinearMap₂' M) (↑toLin' P) (↑toLin' Q)) = ↑toMatrix₂' (↑toLinearMap₂' (Pᵀ ⬝ M ⬝ Q))
Theorem: BoundedSMul.of_norm_smul_le
File: Mathlib/Analysis/Normed/MulAction.lean

tactic: simpa [smul_sub, dist_eq_norm] using h a (b₁ - b₂)
state_before: α : Type u_2
β : Type u_1
inst✝² : SeminormedRing α
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Module α β
h : ∀ (r : α) (x : β), ‖r • x‖ ≤ ‖r‖ * ‖x‖
a : α
b₁ b₂ : β
⊢ dist (a • b₁) (a • b₂) ≤ dist a 0 * dist b₁ b₂

tactic: simpa [sub_smul, dist_eq_norm] using h (a₁ - a₂) b
state_before: α : Type u_2
β : Type u_1
inst✝² : SeminormedRing α
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Module α β
h : ∀ (r : α) (x : β), ‖r • x‖ ≤ ‖r‖ * ‖x‖
a₁ a₂ : α
b : β
⊢ dist (a₁ • b) (a₂ • b) ≤ dist a₁ a₂ * dist b 0
Theorem: ConvexOn.lt_right_of_left_lt'
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [add_comm] at hab hfx⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.592639
α : Type ?u.592642
β : Type u_3
ι : Type ?u.592648
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hfx : f x < f (a • x + b • y)
⊢ f (a • x + b • y) < f y

tactic: exact hf.lt_left_of_right_lt' hy hx hb ha hab hfx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.592639
α : Type ?u.592642
β : Type u_3
ι : Type ?u.592648
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
a b : 𝕜
hx : x ∈ s
hy : y ∈ s
ha : 0 < a
hb : 0 < b
hab : b + a = 1
hfx : f x < f (b • y + a • x)
⊢ f (b • y + a • x) < f y
Theorem: Finmap.mem_singleton
File: Mathlib/Data/Finmap.lean

tactic: simp only [singleton]
state_before: α : Type u
β : α → Type v
x y : α
b : β y
⊢ x ∈ singleton y b ↔ x = y

tactic: erw [mem_cons, mem_nil_iff, or_false_iff]
state_before: α : Type u
β : α → Type v
x y : α
b : β y
⊢ x ∈ ⟦AList.singleton y b⟧ ↔ x = y
Theorem: Inducing.withSeminorms
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [hf.induced]
state_before: 𝕜 : Type u_5
𝕜₂ : Type u_2
𝕝 : Type ?u.841276
𝕝₂ : Type ?u.841279
E : Type u_4
F : Type u_3
G : Type ?u.841288
ι : Type u_1
ι' : Type ?u.841294
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : NormedField 𝕜₂
inst✝⁵ : AddCommGroup F
inst✝⁴ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝³ : RingHomIsometric σ₁₂
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
hι : Nonempty ι
q : SeminormFamily 𝕜₂ F ι
hq : WithSeminorms q
inst✝ : TopologicalSpace E
f : E →ₛₗ[σ₁₂] F
hf : Inducing ↑f
⊢ WithSeminorms (SeminormFamily.comp q f)

tactic: exact f.withSeminorms_induced hq
state_before: 𝕜 : Type u_5
𝕜₂ : Type u_2
𝕝 : Type ?u.841276
𝕝₂ : Type ?u.841279
E : Type u_4
F : Type u_3
G : Type ?u.841288
ι : Type u_1
ι' : Type ?u.841294
inst✝⁹ : NormedField 𝕜
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : NormedField 𝕜₂
inst✝⁵ : AddCommGroup F
inst✝⁴ : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝³ : RingHomIsometric σ₁₂
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
hι : Nonempty ι
q : SeminormFamily 𝕜₂ F ι
hq : WithSeminorms q
inst✝ : TopologicalSpace E
f : E →ₛₗ[σ₁₂] F
hf : Inducing ↑f
⊢ WithSeminorms (SeminormFamily.comp q f)
Theorem: ENNReal.rpow_add_le_mul_rpow_add_rpow
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: rcases eq_or_lt_of_le hp with (rfl | h'p)
state_before: ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)

tactic: convert rpow_arith_mean_le_arith_mean2_rpow (1 / 2) (1 / 2) (2 * z₁) (2 * z₂)
    (ENNReal.add_halves 1) hp using 1
state_before: case inr
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p ≤ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p)

tactic: simp only [rpow_one, sub_self, rpow_zero, one_mul, le_refl]
state_before: case inl
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
hp : 1 ≤ 1
⊢ (z₁ + z₂) ^ 1 ≤ 2 ^ (1 - 1) * (z₁ ^ 1 + z₂ ^ 1)

tactic: simp [← mul_assoc, ENNReal.inv_mul_cancel two_ne_zero two_ne_top]
state_before: case h.e'_3
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ (z₁ + z₂) ^ p = (1 / 2 * (2 * z₁) + 1 / 2 * (2 * z₂)) ^ p

tactic: have _ : p - 1 ≠ 0 := ne_of_gt (sub_pos.2 h'p)
state_before: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p

tactic: simp only [mul_rpow_of_nonneg _ _ (zero_le_one.trans hp), rpow_sub _ _ two_ne_zero two_ne_top,
  div_eq_inv_mul, rpow_one, mul_one]
state_before: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
x✝ : p - 1 ≠ 0
⊢ 2 ^ (p - 1) * (z₁ ^ p + z₂ ^ p) = 1 / 2 * (2 * z₁) ^ p + 1 / 2 * (2 * z₂) ^ p

tactic: ring
state_before: case h.e'_4
ι : Type u
s : Finset ι
z₁ z₂ : ℝ≥0∞
p : ℝ
hp : 1 ≤ p
h'p : 1 < p
x✝ : p - 1 ≠ 0
⊢ 2⁻¹ * 2 ^ p * (z₁ ^ p + z₂ ^ p) = 2⁻¹ * (2 ^ p * z₁ ^ p) + 2⁻¹ * (2 ^ p * z₂ ^ p)
Theorem: smul_eq_zero_iff_eq
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: rw [← inv_smul_smul a x, h, smul_zero]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Group α
inst✝¹ : AddMonoid β
inst✝ : DistribMulAction α β
a : α
x : β
h : a • x = 0
⊢ x = 0
Theorem: Finset.image_preimage
File: Mathlib/Data/Finset/Preimage.lean

tactic: simp only [coe_image, coe_preimage, coe_filter, Set.image_preimage_eq_inter_range,
  ← Set.sep_mem_eq]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : DecidableEq β
f : α → β
s : Finset β
inst✝ : (x : β) → Decidable (x ∈ Set.range f)
hf : InjOn f (f ⁻¹' ↑s)
⊢ ↑(image f (preimage s f hf)) = ↑(filter (fun x => x ∈ Set.range f) s)

tactic: rfl
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : DecidableEq β
f : α → β
s : Finset β
inst✝ : (x : β) → Decidable (x ∈ Set.range f)
hf : InjOn f (f ⁻¹' ↑s)
⊢ {x | x ∈ ↑s ∧ x ∈ Set.range f} = {x | x ∈ s ∧ x ∈ Set.range f}
Theorem: NNReal.tendsto_pow_atTop_nhds_0_of_lt_1
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simp only [NNReal.coe_pow, NNReal.coe_zero,
  _root_.tendsto_pow_atTop_nhds_0_of_lt_1 r.coe_nonneg hr]
state_before: α : Type ?u.41397
β : Type ?u.41400
ι : Type ?u.41403
r : ℝ≥0
hr : r < 1
⊢ Tendsto (fun a => ↑(r ^ a)) atTop (𝓝 ↑0)
Theorem: NNReal.coe_sub
File: Mathlib/Data/Real/NNReal.lean

tactic: simp [show (r₂ : ℝ) ≤ r₁ from h]
state_before: r₁ r₂ : ℝ≥0
h : r₂ ≤ r₁
⊢ ↑r₂ ≤ ↑r₁ - 0
Theorem: Submonoid.LocalizationMap.mk'_eq_iff_eq_mul
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [eq_comm, eq_mk'_iff_mul_eq, eq_comm]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.800895
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
z : N
⊢ mk' f x y = z ↔ ↑(toMap f) x = z * ↑(toMap f) ↑y
Theorem: Ordinal.lift_is_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [h, ← e, lift_succ]
state_before: α : Type ?u.87265
β : Type ?u.87268
γ : Type ?u.87271
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
x✝ : ∃ a, lift o = succ a
a : Ordinal
h : lift o = succ a
b : Ordinal
e : lift b = a
⊢ lift o = lift (succ b)

tactic: simp only [h, lift_succ]
state_before: α : Type ?u.87265
β : Type ?u.87268
γ : Type ?u.87271
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
x✝ : ∃ a, o = succ a
a : Ordinal
h : o = succ a
⊢ lift o = succ (lift a)
Theorem: Class.mem_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: constructor
state_before: x y : Class
⊢ y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z

tactic: rintro ⟨w, rfl, z, hzx, hwz⟩
state_before: case mp
x y : Class
⊢ y ∈ ⋃₀ x → ∃ z, z ∈ x ∧ y ∈ z

tactic: exact ⟨z, hzx, coe_mem.2 hwz⟩
state_before: case mp.intro.intro.intro.intro
x : Class
w : ZFSet
z : Set ZFSet
hzx : z ∈ classToCong x
hwz : w ∈ z
⊢ ∃ z, z ∈ x ∧ ↑w ∈ z

tactic: rintro ⟨w, hwx, z, rfl, hwz⟩
state_before: case mpr
x y : Class
⊢ (∃ z, z ∈ x ∧ y ∈ z) → y ∈ ⋃₀ x

tactic: exact ⟨z, rfl, w, hwx, hwz⟩
state_before: case mpr.intro.intro.intro.intro
x w : Class
hwx : w ∈ x
z : ZFSet
hwz : w z
⊢ ↑z ∈ ⋃₀ x
Theorem: TendstoUniformlyOn.congr
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at hf⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOn F f p s
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ TendstoUniformlyOn F' f p s

tactic: refine' hf.congr _
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ TendstoUniformlyOnFilter F' f p (𝓟 s)

tactic: rw [eventually_iff] at hff'⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : ∀ᶠ (n : ι) in p, EqOn (F n) (F' n) s
⊢ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, F n.fst n.snd = F' n.fst n.snd

tactic: simp only [Set.EqOn] at hff'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | EqOn (F x) (F' x) s} ∈ p
⊢ {x | F x.fst x.snd = F' x.fst x.snd} ∈ p ×ˢ 𝓟 s

tactic: simp only [mem_prod_principal, hff', mem_setOf_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p (𝓟 s)
hff' : {x | ∀ ⦃x_1 : α⦄, x_1 ∈ s → F x x_1 = F' x x_1} ∈ p
⊢ {x | F x.fst x.snd = F' x.fst x.snd} ∈ p ×ˢ 𝓟 s
Theorem: ENNReal.tsum_biUnion_le_tsum
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp
state_before: α : Type u_2
β : Type ?u.277982
γ : Type ?u.277985
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
ι : Type u_1
f : α → ℝ≥0∞
s : Set ι
t : ι → Set α
⊢ (⋃ (i : ι) (_ : i ∈ s), t i) = ⋃ (i : ↑s), t ↑i
Theorem: TensorAlgebra.lift_unique
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: rw [← (lift R).symm_apply_eq]
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
g : TensorAlgebra R M →ₐ[R] A
⊢ LinearMap.comp (AlgHom.toLinearMap g) (ι R) = f ↔ g = ↑(lift R) f

tactic: simp only [lift, Equiv.coe_fn_symm_mk]
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
g : TensorAlgebra R M →ₐ[R] A
⊢ LinearMap.comp (AlgHom.toLinearMap g) (ι R) = f ↔ ↑(lift R).symm g = f
Theorem: Ordinal.enum_zero_le
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← enum_typein r a, enum_le_enum r]
state_before: α : Type u_1
β : Type ?u.194526
γ : Type ?u.194529
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
h0 : 0 < type r
a : α
⊢ ¬r a (enum r 0 h0)

tactic: apply Ordinal.zero_le
state_before: α : Type u_1
β : Type ?u.194526
γ : Type ?u.194529
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
h0 : 0 < type r
a : α
⊢ 0 ≤ typein r a
Theorem: List.formPerm_apply_nthLe_zero
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rcases l with (_ | ⟨x, _ | ⟨y, tl⟩⟩)
state_before: α : Type u_1
β : Type ?u.668958
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
hl : 1 < length l
⊢ ↑(formPerm l) (nthLe l 0 (_ : 0 < length l)) = nthLe l 1 hl

tactic: simp at hl
state_before: case nil
α : Type u_1
β : Type ?u.668958
inst✝ : DecidableEq α
l : List α
x : α
h : Nodup []
hl : 1 < length []
⊢ ↑(formPerm []) (nthLe [] 0 (_ : 0 < length [])) = nthLe [] 1 hl

tactic: simp
state_before: case cons.nil
α : Type u_1
β : Type ?u.668958
inst✝ : DecidableEq α
l : List α
x✝ x : α
h : Nodup [x]
hl : 1 < length [x]
⊢ ↑(formPerm [x]) (nthLe [x] 0 (_ : 0 < length [x])) = nthLe [x] 1 hl

tactic: simpa using formPerm_apply_head _ _ _ h
state_before: case cons.cons
α : Type u_1
β : Type ?u.668958
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : Nodup (x :: y :: tl)
hl : 1 < length (x :: y :: tl)
⊢ ↑(formPerm (x :: y :: tl)) (nthLe (x :: y :: tl) 0 (_ : 0 < length (x :: y :: tl))) = nthLe (x :: y :: tl) 1 hl
Theorem: generateFrom_piiUnionInter_measurableSet
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: refine' le_antisymm _ _
state_before: α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
⊢ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S) = ⨆ (i : ι) (_ : i ∈ S), m i

tactic: rw [← @generateFrom_measurableSet α (⨆ i ∈ S, m i)]
state_before: case refine'_1
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
⊢ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S) ≤ ⨆ (i : ι) (_ : i ∈ S), m i

tactic: exact generateFrom_mono (measurableSet_iSup_of_mem_piiUnionInter m S)
state_before: case refine'_1
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
⊢ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S) ≤ generateFrom {s | MeasurableSet s}

tactic: refine' iSup₂_le fun i hi => _
state_before: case refine'_2
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
⊢ (⨆ (i : ι) (_ : i ∈ S), m i) ≤ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S)

tactic: rw [← @generateFrom_measurableSet α (m i)]
state_before: case refine'_2
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
i : ι
hi : i ∈ S
⊢ m i ≤ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S)

tactic: exact generateFrom_mono (mem_piiUnionInter_of_measurableSet m hi)
state_before: case refine'_2
α : Type u_1
ι : Type u_2
m : ι → MeasurableSpace α
S : Set ι
i : ι
hi : i ∈ S
⊢ generateFrom {s | MeasurableSet s} ≤ generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S)
Theorem: Primrec.option_getD
File: Mathlib/Computability/Primrec.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type ?u.116351
γ : Type ?u.116354
δ : Type ?u.116357
σ : Type ?u.116360
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
x✝ : Option α × α
o : Option α
a : α
⊢ (Option.casesOn ((fun a x => a) (o, a).fst (o, a).snd) ((fun x b => b) (o, a).fst (o, a).snd) fun b => b) =
    Option.getD (o, a).fst (o, a).snd
Theorem: Option.bind_eq_none
File: Std/Data/Option/Lemmas.lean

tactic: simp only [eq_none_iff_forall_not_mem, not_exists, not_and, mem_def, bind_eq_some]
state_before: α : Type u_1
β : Type u_2
o : Option α
f : α → Option β
⊢ Option.bind o f = none ↔ ∀ (b : β) (a : α), a ∈ o → ¬b ∈ f a
Theorem: AffineSubspace.spanPoints_subset_coe_of_subset_coe
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rintro p ⟨p1, hp1, v, hv, hp⟩
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
⊢ spanPoints k s ⊆ ↑s1

tactic: rw [hp]
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
⊢ p ∈ ↑s1

tactic: have hp1s1 : p1 ∈ (s1 : Set P) := Set.mem_of_mem_of_subset hp1 h
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
⊢ v +ᵥ p1 ∈ ↑s1

tactic: refine' vadd_mem_of_mem_direction _ hp1s1
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
hp1s1 : p1 ∈ ↑s1
⊢ v +ᵥ p1 ∈ ↑s1

tactic: have hs : vectorSpan k s ≤ s1.direction := vectorSpan_mono k h
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
hp1s1 : p1 ∈ ↑s1
⊢ v ∈ direction s1

tactic: rw [SetLike.le_def] at hs
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
hp1s1 : p1 ∈ ↑s1
hs : vectorSpan k s ≤ direction s1
⊢ v ∈ direction s1

tactic: rw [← SetLike.mem_coe]
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
hp1s1 : p1 ∈ ↑s1
hs : ∀ ⦃x : V⦄, x ∈ vectorSpan k s → x ∈ direction s1
⊢ v ∈ direction s1

tactic: exact Set.mem_of_mem_of_subset hv hs
state_before: case intro.intro.intro.intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
s1 : AffineSubspace k P
h : s ⊆ ↑s1
p p1 : P
hp1 : p1 ∈ s
v : V
hv : v ∈ vectorSpan k s
hp : p = v +ᵥ p1
hp1s1 : p1 ∈ ↑s1
hs : ∀ ⦃x : V⦄, x ∈ vectorSpan k s → x ∈ direction s1
⊢ v ∈ ↑(direction s1)
Theorem: Function.support_prod
File: Mathlib/Algebra/Support.lean

tactic: simp [support, Ne.def, Finset.prod_eq_zero_iff, mem_setOf_eq, Set.mem_iInter, not_exists]
state_before: α : Type u_2
β : Type u_3
A : Type u_1
B : Type ?u.102217
M : Type ?u.102220
N : Type ?u.102223
P : Type ?u.102226
R : Type ?u.102229
S : Type ?u.102232
G : Type ?u.102235
M₀ : Type ?u.102238
G₀ : Type ?u.102241
ι : Sort ?u.102244
inst✝² : CommMonoidWithZero A
inst✝¹ : NoZeroDivisors A
inst✝ : Nontrivial A
s : Finset α
f : α → β → A
x : β
⊢ (x ∈ support fun x => ∏ i in s, f i x) ↔ x ∈ ⋂ (i : α) (_ : i ∈ s), support (f i)
Theorem: CategoryTheory.isSeparator_sigma_of_isSeparator
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
b : β
hb : IsSeparator (f b)
⊢ {f b} ⊆ Set.range f