tasksource/leandojo huggingface dataset:
Theorem: DenseInducing.extend_eq'
File: Mathlib/Topology/DenseEmbedding.lean

tactic: rcases hf (i a) with ⟨b, hb⟩
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.8090
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝² : TopologicalSpace δ
f✝ : γ → α
g : γ → δ
h : δ → β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
di : DenseInducing i
hf : ∀ (b : β), ∃ c, Tendsto f (comap i (𝓝 b)) (𝓝 c)
a : α
⊢ extend di f (i a) = f a

tactic: refine' di.extend_eq_at' b _
state_before: case intro
α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.8090
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝² : TopologicalSpace δ
f✝ : γ → α
g : γ → δ
h : δ → β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
di : DenseInducing i
hf : ∀ (b : β), ∃ c, Tendsto f (comap i (𝓝 b)) (𝓝 c)
a : α
b : γ
hb : Tendsto f (comap i (𝓝 (i a))) (𝓝 b)
⊢ extend di f (i a) = f a

tactic: rwa [← di.toInducing.nhds_eq_comap] at hb
state_before: case intro
α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.8090
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝² : TopologicalSpace δ
f✝ : γ → α
g : γ → δ
h : δ → β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
di : DenseInducing i
hf : ∀ (b : β), ∃ c, Tendsto f (comap i (𝓝 b)) (𝓝 c)
a : α
b : γ
hb : Tendsto f (comap i (𝓝 (i a))) (𝓝 b)
⊢ Tendsto f (𝓝 a) (𝓝 b)
Theorem: Int.lt_of_sub_pos
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h b
state_before: a b : Int
h : 0 < a - b
⊢ b < a

tactic: rwa [Int.sub_add_cancel, Int.zero_add] at h
state_before: a b : Int
h✝ : 0 < a - b
h : 0 + b < a - b + b
⊢ b < a
Theorem: Monotone.continuousWithinAt_Iio_iff_leftLim_eq
File: Mathlib/Topology/Algebra/Order/LeftRightLim.lean

tactic: rcases eq_or_ne (𝓝[<] x) ⊥ with (h' | h')
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
⊢ ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x

tactic: haveI : (𝓝[Iio x] x).NeBot := neBot_iff.2 h'
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h' : 𝓝[Iio x] x ≠ ⊥
⊢ ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x

tactic: refine' ⟨fun h => tendsto_nhds_unique (hf.tendsto_leftLim x) h.tendsto, fun h => _⟩
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h' : 𝓝[Iio x] x ≠ ⊥
this : NeBot (𝓝[Iio x] x)
⊢ ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x

tactic: have := hf.tendsto_leftLim x
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h' : 𝓝[Iio x] x ≠ ⊥
this : NeBot (𝓝[Iio x] x)
h : leftLim f x = f x
⊢ ContinuousWithinAt f (Iio x) x

tactic: rwa [h] at this
state_before: case inr
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h' : 𝓝[Iio x] x ≠ ⊥
this✝ : NeBot (𝓝[Iio x] x)
h : leftLim f x = f x
this : Tendsto f (𝓝[Iio x] x) (𝓝 (leftLim f x))
⊢ ContinuousWithinAt f (Iio x) x

tactic: simp [leftLim_eq_of_eq_bot f h', ContinuousWithinAt, h']
state_before: case inl
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h' : 𝓝[Iio x] x = ⊥
⊢ ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x
Theorem: HasFPowerSeriesOnBall.hasSum_sub
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: have : y - x ∈ EMetric.ball (0 : E) r := by simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.416023
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
⊢ HasSum (fun n => ↑(p n) fun x_1 => y - x) (f y)

tactic: simpa only [add_sub_cancel'_right] using hf.hasSum this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.416023
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
this : y - x ∈ EMetric.ball 0 r
⊢ HasSum (fun n => ↑(p n) fun x_1 => y - x) (f y)

tactic: simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.416023
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
⊢ y - x ∈ EMetric.ball 0 r
Theorem: Matrix.isUnit_iff_isUnit_det
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp only [← nonempty_invertible_iff_isUnit, (invertibleEquivDetInvertible A).nonempty_congr]
state_before: l : Type ?u.86247
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ IsUnit A ↔ IsUnit (det A)
Theorem: Rel.image_id
File: Mathlib/Data/Rel.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.15405
γ : Type ?u.15408
r : Rel α β
s : Set α
⊢ image Eq s = s

tactic: simp [mem_image]
state_before: case h
α : Type u_1
β : Type ?u.15405
γ : Type ?u.15408
r : Rel α β
s : Set α
x : α
⊢ x ∈ image Eq s ↔ x ∈ s
Theorem: FirstOrder.Language.Term.realize_restrictVarLeft
File: Mathlib/ModelTheory/Semantics.lean

tactic: induction' t with a _ _ _ ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.12423
P : Type ?u.12426
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_1
t : Term L (α ⊕ γ)
s : Set α
h : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft t (Set.inclusion h)) = realize (Sum.elim v xs) t

tactic: cases a <;> rfl
state_before: case var
L : Language
L' : Language
M : Type w
N : Type ?u.12423
P : Type ?u.12426
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_1
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
a : α ⊕ γ
h : ↑(varFinsetLeft (var a)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (var a) (Set.inclusion h)) = realize (Sum.elim v xs) (var a)

tactic: simp_rw [varFinsetLeft, Finset.coe_biUnion, Set.iUnion_subset_iff] at h
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.12423
P : Type ?u.12426
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_1
t : Term L (α ⊕ γ)
s : Set α
h✝ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L (α ⊕ γ)
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinsetLeft (_ts✝ a)) ⊆ s),
    realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (_ts✝ a) (Set.inclusion h)) =
      realize (Sum.elim v xs) (_ts✝ a)
h : ↑(varFinsetLeft (func _f✝ _ts✝)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (func _f✝ _ts✝) (Set.inclusion h)) =
    realize (Sum.elim v xs) (func _f✝ _ts✝)

tactic: exact congr rfl (funext fun i => ih i (h i (Finset.mem_univ i)))
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.12423
P : Type ?u.12426
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
α : Type u'
β : Type v'
inst✝ : DecidableEq α
γ : Type u_1
t : Term L (α ⊕ γ)
s : Set α
h✝¹ : ↑(varFinsetLeft t) ⊆ s
v : α → M
xs : γ → M
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L (α ⊕ γ)
ih :
  ∀ (a : Fin l✝) (h : ↑(varFinsetLeft (_ts✝ a)) ⊆ s),
    realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (_ts✝ a) (Set.inclusion h)) =
      realize (Sum.elim v xs) (_ts✝ a)
h✝ : ↑(Finset.biUnion Finset.univ fun i => varFinsetLeft (_ts✝ i)) ⊆ s
h : ∀ (i : Fin l✝), i ∈ ↑Finset.univ → ↑(varFinsetLeft (_ts✝ i)) ⊆ s
⊢ realize (Sum.elim (v ∘ Subtype.val) xs) (restrictVarLeft (func _f✝ _ts✝) (Set.inclusion h✝)) =
    realize (Sum.elim v xs) (func _f✝ _ts✝)
Theorem: Int.pred_toNat
File: Std/Data/Int/Lemmas.lean

tactic: simp [ofNat_add]
state_before: n : Nat
⊢ toNat (↑(n + 1) - 1) = toNat ↑(n + 1) - 1
Theorem: LieModule.mem_ker
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: simp only [LieModule.ker, LieHom.mem_ker, LinearMap.ext_iff, LinearMap.zero_apply,
  toEndomorphism_apply_apply]
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
x : L
⊢ x ∈ LieModule.ker R L M ↔ ∀ (m : M), ⁅x, m⁆ = 0
Theorem: Algebra.sInf_toSubsemiring
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Set (Subalgebra R A)
⊢ ↑(sInf S).toSubsemiring = ↑(sInf (Subalgebra.toSubsemiring '' S))
Theorem: Real.pi_gt_three
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_lower_bound [23/16]
state_before: ⊢ 3 < π
Theorem: Cycle.formPerm_eq_self_of_not_mem
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: induction s using Quot.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : Nodup s
x : α
hx : ¬x ∈ s
⊢ ↑(formPerm s h) x = x

tactic: simpa using List.formPerm_eq_self_of_not_mem _ _ hx
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
x : α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hx : ¬x ∈ Quot.mk Setoid.r a✝
⊢ ↑(formPerm (Quot.mk Setoid.r a✝) h) x = x
Theorem: Multiset.count_map
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Bool.beq_eq_decide_eq, eq_comm, count, countp_map]
state_before: α✝ : Type ?u.414392
β✝ : Type ?u.414395
γ : Type ?u.414398
inst✝¹ : DecidableEq α✝
α : Type u_1
β : Type u_2
f : α → β
s : Multiset α
inst✝ : DecidableEq β
b : β
⊢ count b (map f s) = ↑card (filter (fun a => b = f a) s)
Theorem: Subsemiring.coe_sSup_of_directedOn
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: simp [mem_sSup_of_directedOn Sne hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S✝
inst✝ : NonAssocSemiring T
S : Set (Subsemiring R)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ (s : Subsemiring R) (_ : s ∈ S), ↑s
Theorem: MvPolynomial.degrees_add
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: simp_rw [degrees_def]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ degrees (p + q) ≤ degrees p ⊔ degrees q

tactic: refine' Finset.sup_le fun b hb => _
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ (Finset.sup (support (p + q)) fun s => ↑toMultiset s) ≤
    (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s

tactic: have := Finsupp.support_add hb
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
b : σ →₀ ℕ
hb : b ∈ support (p + q)
⊢ ↑toMultiset b ≤ (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s

tactic: rw [Finset.mem_union] at this
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
b : σ →₀ ℕ
hb : b ∈ support (p + q)
this : b ∈ p.support ∪ q.support
⊢ ↑toMultiset b ≤ (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s

tactic: cases' this with h h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
b : σ →₀ ℕ
hb : b ∈ support (p + q)
this : b ∈ p.support ∨ b ∈ q.support
⊢ ↑toMultiset b ≤ (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s

tactic: exact le_sup_of_le_left (Finset.le_sup h)
state_before: case inl
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
b : σ →₀ ℕ
hb : b ∈ support (p + q)
h : b ∈ p.support
⊢ ↑toMultiset b ≤ (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s

tactic: exact le_sup_of_le_right (Finset.le_sup h)
state_before: case inr
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.31525
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
b : σ →₀ ℕ
hb : b ∈ support (p + q)
h : b ∈ q.support
⊢ ↑toMultiset b ≤ (Finset.sup (support p) fun s => ↑toMultiset s) ⊔ Finset.sup (support q) fun s => ↑toMultiset s
Theorem: CstarRing.mul_star_self_eq_zero_iff
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: simpa only [star_eq_zero, star_star] using @star_mul_self_eq_zero_iff _ _ _ _ (star x)
state_before: 𝕜 : Type ?u.44392
E : Type u_1
α : Type ?u.44398
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x * x⋆ = 0 ↔ x = 0
Theorem: CategoryTheory.Limits.biproduct.lift_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: apply biproduct.hom_ext
state_before: C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
f : J → C
inst✝ : HasBiproduct f
T : C
g : (j : J) → T ⟶ f j
⊢ lift g = ∑ j : J, g j ≫ ι f j

tactic: intro j
state_before: case w
C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
f : J → C
inst✝ : HasBiproduct f
T : C
g : (j : J) → T ⟶ f j
⊢ ∀ (j : J), lift g ≫ π (fun b => f b) j = (∑ j : J, g j ≫ ι f j) ≫ π (fun b => f b) j

tactic: simp only [sum_comp, biproduct.ι_π, comp_dite, biproduct.lift_π, Category.assoc, comp_zero,
  Finset.sum_dite_eq', Finset.mem_univ, eqToHom_refl, Category.comp_id, if_true]
state_before: case w
C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
f : J → C
inst✝ : HasBiproduct f
T : C
g : (j : J) → T ⟶ f j
j : J
⊢ lift g ≫ π (fun b => f b) j = (∑ j : J, g j ≫ ι f j) ≫ π (fun b => f b) j
Theorem: ENNReal.toReal_ofReal_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.toReal_mul, ENNReal.toReal_ofReal h]
state_before: α : Type ?u.826990
β : Type ?u.826993
a✝ b c✝ d : ℝ≥0∞
r p q : ℝ≥0
c : ℝ
a : ℝ≥0∞
h : 0 ≤ c
⊢ ENNReal.toReal (ENNReal.ofReal c * a) = c * ENNReal.toReal a
Theorem: Submodule.mul_toAddSubmonoid
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: dsimp [HMul.hMul, Mul.mul]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (M * N).toAddSubmonoid = M.toAddSubmonoid * N.toAddSubmonoid

tactic: rw [map₂, iSup_toAddSubmonoid]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (map₂ (LinearMap.mul R A) M N).toAddSubmonoid =
    ⨆ (s : { x // x ∈ M.toAddSubmonoid }), AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid

tactic: rfl
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N✝ P Q : Submodule R A
m n : A
M N : Submodule R A
⊢ (⨆ (i : { x // x ∈ M }), (map (↑(LinearMap.mul R A) ↑i) N).toAddSubmonoid) =
    ⨆ (s : { x // x ∈ M.toAddSubmonoid }), AddSubmonoid.map (AddMonoidHom.mulLeft ↑s) N.toAddSubmonoid
Theorem: Set.image2_iInter_subset_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_subset_iff, mem_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.252102
ι₂ : Sort ?u.252105
κ : ι → Sort ?u.252110
κ₁ : ι → Sort ?u.252115
κ₂ : ι → Sort ?u.252120
κ' : ι' → Sort ?u.252125
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ image2 f s (⋂ (i : ι), t i) ⊆ ⋂ (i : ι), image2 f s (t i)

tactic: exact fun x hx y hy i => mem_image2_of_mem hx (hy _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.252102
ι₂ : Sort ?u.252105
κ : ι → Sort ?u.252110
κ₁ : ι → Sort ?u.252115
κ₂ : ι → Sort ?u.252120
κ' : ι' → Sort ?u.252125
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : ι → Set β
⊢ ∀ (x : α), x ∈ s → ∀ (y : β), (∀ (i : ι), y ∈ t i) → ∀ (i : ι), f x y ∈ image2 f s (t i)
Theorem: div_sub_div_same
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [sub_eq_add_neg, ← neg_div, div_add_div_same, sub_eq_add_neg]
state_before: α : Type ?u.39149
β : Type ?u.39152
K : Type u_1
inst✝ : DivisionRing K
a✝ b✝ c✝ d a b c : K
⊢ a / c - b / c = (a - b) / c
Theorem: sign_mul
File: Mathlib/Data/Sign.lean

tactic: rcases lt_trichotomy x 0 with (hx | hx | hx) <;> rcases lt_trichotomy y 0 with (hy | hy | hy) <;>
  simp [hx, hy, mul_pos_of_neg_of_neg, mul_neg_of_neg_of_pos, mul_neg_of_pos_of_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b x y : α
⊢ ↑sign (x * y) = ↑sign x * ↑sign y
Theorem: List.cons_bagInter_of_neg
File: Mathlib/Data/List/Lattice.lean

tactic: cases l₂
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ l₂
⊢ List.bagInter (a :: l₁) l₂ = List.bagInter l₁ l₂

tactic: simp only [erase_of_not_mem h, List.bagInter, if_neg (mt mem_of_elem_eq_true h)]
state_before: case cons
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
head✝ : α
tail✝ : List α
h : ¬a ∈ head✝ :: tail✝
⊢ List.bagInter (a :: l₁) (head✝ :: tail✝) = List.bagInter l₁ (head✝ :: tail✝)

tactic: simp only [bagInter_nil]
state_before: case nil
α : Type u_1
l l₁✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ []
⊢ List.bagInter (a :: l₁) [] = List.bagInter l₁ []
Theorem: MeasureTheory.FinStronglyMeasurable.inf
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine'
  ⟨fun n => hf.approx n ⊓ hg.approx n, fun n => _, fun x =>
    (hf.tendsto_approx x).inf_right_nhds (hg.tendsto_approx x)⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.280281
ι : Type ?u.280284
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ FinStronglyMeasurable (f ⊓ g) μ

tactic: refine' (measure_mono (support_inf _ _)).trans_lt _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.280281
ι : Type ?u.280284
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ ↑↑μ (support ↑((fun n => FinStronglyMeasurable.approx hf n ⊓ FinStronglyMeasurable.approx hg n) n)) < ⊤

tactic: exact measure_union_lt_top_iff.mpr ⟨hf.fin_support_approx n, hg.fin_support_approx n⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.280281
ι : Type ?u.280284
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ ↑↑μ
      ((support fun x => ↑(FinStronglyMeasurable.approx hf n) x) ∪
        support fun x => ↑(FinStronglyMeasurable.approx hg n) x) <
    ⊤
Theorem: SubMulAction.stabilizer_of_subMul.submonoid
File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

tactic: ext
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Monoid R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ MulAction.Stabilizer.submonoid R m = MulAction.Stabilizer.submonoid R ↑m

tactic: simp only [MulAction.mem_stabilizer_submonoid_iff, ← SubMulAction.val_smul, SetLike.coe_eq_coe]
state_before: case h
S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Monoid R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
x✝ : R
⊢ x✝ ∈ MulAction.Stabilizer.submonoid R m ↔ x✝ ∈ MulAction.Stabilizer.submonoid R ↑m
Theorem: List.getLast?_isNone
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.34045
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
⊢ Option.isNone (getLast? []) = true ↔ [] = []

tactic: simp
state_before: ι : Type ?u.34045
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
⊢ Option.isNone (getLast? [a]) = true ↔ [a] = []

tactic: simp [@getLast?_isNone (b :: l)]
state_before: ι : Type ?u.34045
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
⊢ Option.isNone (getLast? (a :: b :: l)) = true ↔ a :: b :: l = []
Theorem: List.kerase_cons_eq
File: Mathlib/Data/List/Sigma.lean

tactic: simp [kerase, h]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
s : Sigma β
l : List (Sigma β)
h : a = s.fst
⊢ kerase a (s :: l) = l
Theorem: Ideal.le_span_singleton_mul_iff
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [mem_span_singleton_mul]
state_before: R : Type u
ι : Type ?u.230454
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x : R
I J : Ideal R
⊢ (∀ {zI : R}, zI ∈ I → zI ∈ span {x} * J) ↔ ∀ (zI : R), zI ∈ I → ∃ zJ, zJ ∈ J ∧ x * zJ = zI
Theorem: differentiable_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.427827
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.427922
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : Differentiable 𝕜 fun y => -f y
⊢ Differentiable 𝕜 f
Theorem: IsROrC.I_mul_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [I_re, zero_sub, I_im', zero_mul, mul_re]
state_before: K : Type u_1
E : Type ?u.2411518
inst✝ : IsROrC K
z : K
⊢ ↑re (I * z) = -↑im z
Theorem: continuousAt_of_tendsto_nhds
File: Mathlib/Topology/Separation.lean

tactic: rwa [eq_of_tendsto_nhds h]
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space β
f : α → β
a : α
b : β
h : Tendsto f (𝓝 a) (𝓝 b)
⊢ Tendsto f (𝓝 a) (𝓝 (f a))