tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Projective.of_iso
File: Mathlib/CategoryTheory/Preadditive/Projective.lean

tactic: simp [hf']
state_before: C : Type u
inst✝ : Category C
P Q : C
i : P ≅ Q
hP : Projective P
E✝ X✝ : C
f : Q ⟶ X✝
e : E✝ ⟶ X✝
e_epi : Epi e
f' : P ⟶ E✝
hf' : f' ≫ e = i.hom ≫ f
⊢ (i.inv ≫ f') ≫ e = f
Theorem: ContinuousMap.summable_of_locally_summable_norm
File: Mathlib/Topology/ContinuousFunction/Compact.lean

tactic: refine' (ContinuousMap.exists_tendsto_compactOpen_iff_forall _).2 fun K hK => _
state_before: X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
⊢ Summable F

tactic: lift K to Compacts X using hK
state_before: X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Set X
hK : IsCompact K
⊢ ∃ f, Tendsto (fun i => restrict K (∑ b in i, F b)) atTop (𝓝 f)

tactic: have A : ∀ s : Finset ι, restrict (↑K) (∑ i in s, F i) = ∑ i in s, restrict K (F i) := by
  intro s
  ext1 x
  simp
state_before: case intro
X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Compacts X
⊢ ∃ f, Tendsto (fun i => restrict (↑K) (∑ b in i, F b)) atTop (𝓝 f)

tactic: simpa only [HasSum, A] using summable_of_summable_norm (hF K)
state_before: case intro
X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Compacts X
A : ∀ (s : Finset ι), restrict (↑K) (∑ i in s, F i) = ∑ i in s, restrict (↑K) (F i)
⊢ ∃ f, Tendsto (fun i => restrict (↑K) (∑ b in i, F b)) atTop (𝓝 f)

tactic: intro s
state_before: X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Compacts X
⊢ ∀ (s : Finset ι), restrict (↑K) (∑ i in s, F i) = ∑ i in s, restrict (↑K) (F i)

tactic: ext1 x
state_before: X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Compacts X
s : Finset ι
⊢ restrict (↑K) (∑ i in s, F i) = ∑ i in s, restrict (↑K) (F i)

tactic: simp
state_before: case h
X : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : T2Space X
inst✝² : LocallyCompactSpace X
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : CompleteSpace E
ι : Type u_1
F : ι → C(X, E)
hF : ∀ (K : Compacts X), Summable fun i => ‖restrict (↑K) (F i)‖
K : Compacts X
s : Finset ι
x : ↑↑K
⊢ ↑(restrict (↑K) (∑ i in s, F i)) x = ↑(∑ i in s, restrict (↑K) (F i)) x
Theorem: Set.countable_union
File: Mathlib/Data/Set/Countable.lean

tactic: simp [union_eq_iUnion, and_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s t : Set α
⊢ Set.Countable (s ∪ t) ↔ Set.Countable s ∧ Set.Countable t
Theorem: LocalHomeomorph.extend_coord_change_source
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: simp_rw [LocalEquiv.trans_source, I.image_eq, extend_source, LocalEquiv.symm_source,
  extend_target, inter_right_comm _ (range I)]
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.166336
M' : Type ?u.166339
H' : Type ?u.166342
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ (LocalEquiv.symm (extend f I) ≫ extend f' I).source = ↑I '' (LocalHomeomorph.symm f ≫ₕ f').toLocalEquiv.source

tactic: rfl
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.166336
M' : Type ?u.166339
H' : Type ?u.166342
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ ↑(ModelWithCorners.symm I) ⁻¹' f.target ∩ ↑(LocalEquiv.symm (extend f I)) ⁻¹' f'.source ∩ range ↑I =
    ↑(ModelWithCorners.symm I) ⁻¹' (LocalHomeomorph.symm f ≫ₕ f').toLocalEquiv.source ∩ range ↑I
Theorem: UniformSpace.Completion.coe_inv
File: Mathlib/Topology/Algebra/UniformField.lean

tactic: by_cases h : x = 0
state_before: K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
⊢ (↑K x)⁻¹ = ↑K x⁻¹

tactic: rw [h, inv_zero]
state_before: case pos
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : x = 0
⊢ (↑K x)⁻¹ = ↑K x⁻¹

tactic: dsimp [Inv.inv]
state_before: case pos
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : x = 0
⊢ (↑K 0)⁻¹ = ↑K 0

tactic: norm_cast
state_before: case pos
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : x = 0
⊢ (if ↑K 0 = 0 then 0 else hatInv (↑K 0)) = ↑K 0

tactic: simp
state_before: case pos
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : x = 0
⊢ (if 0 = 0 then 0 else hatInv 0) = 0

tactic: conv_lhs => dsimp [Inv.inv]
state_before: case neg
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : ¬x = 0
⊢ (↑K x)⁻¹ = ↑K x⁻¹

tactic: rw [if_neg]
state_before: case neg
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : ¬x = 0
⊢ (if ↑K x = 0 then 0 else hatInv (↑K x)) = ↑K x⁻¹

tactic: exact hatInv_extends h
state_before: case neg
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : ¬x = 0
⊢ hatInv (↑K x) = ↑K x⁻¹

tactic: exact fun H => h (denseEmbedding_coe.inj H)
state_before: case neg.hnc
K : Type u_1
inst✝³ : Field K
inst✝² : UniformSpace K
inst✝¹ : TopologicalDivisionRing K
inst✝ : CompletableTopField K
x : K
h : ¬x = 0
⊢ ¬↑K x = 0
Theorem: Perfect.closure_nhds_inter
File: Mathlib/Topology/Perfect.lean

tactic: constructor
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Perfect C
x : α
xC : x ∈ C
xU : x ∈ U
Uop : IsOpen U
⊢ Perfect (closure (U ∩ C)) ∧ Set.Nonempty (closure (U ∩ C))

tactic: apply Nonempty.closure
state_before: case right
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Perfect C
x : α
xC : x ∈ C
xU : x ∈ U
Uop : IsOpen U
⊢ Set.Nonempty (closure (U ∩ C))

tactic: exact ⟨x, ⟨xU, xC⟩⟩
state_before: case right.a
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Perfect C
x : α
xC : x ∈ C
xU : x ∈ U
Uop : IsOpen U
⊢ Set.Nonempty (U ∩ C)

tactic: apply Preperfect.perfect_closure
state_before: case left
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Perfect C
x : α
xC : x ∈ C
xU : x ∈ U
Uop : IsOpen U
⊢ Perfect (closure (U ∩ C))

tactic: exact hC.acc.open_inter Uop
state_before: case left.hC
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Perfect C
x : α
xC : x ∈ C
xU : x ∈ U
Uop : IsOpen U
⊢ Preperfect (U ∩ C)
Theorem: map_mem_closure₂
File: Mathlib/Topology/Constructions.lean

tactic: simpa only [closure_prod_eq] using mk_mem_prod ha hb
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.62376
ε : Type ?u.62379
ζ : Type ?u.62382
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β → γ
a : α
b : β
s : Set α
t : Set β
u : Set γ
hf : Continuous (uncurry f)
ha : a ∈ closure s
hb : b ∈ closure t
h : ∀ (a : α), a ∈ s → ∀ (b : β), b ∈ t → f a b ∈ u
⊢ (a, b) ∈ closure (s ×ˢ t)
Theorem: LinearMap.lTensor_id_apply
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: rw [lTensor_id, id_coe, id.def]
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.1263573
inst✝¹³ : Monoid R'
R'' : Type ?u.1263579
inst✝¹² : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.1263591
Q : Type ?u.1263594
S : Type ?u.1263597
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
x : M ⊗[R] N
⊢ ↑(lTensor M id) x = x
Theorem: Finmap.extract_eq_lookup_erase
File: Mathlib/Data/Finmap.lean

tactic: simp [extract]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s✝ : Finmap β
s : AList β
⊢ extract a ⟦s⟧ = (lookup a ⟦s⟧, erase a ⟦s⟧)
Theorem: MvPFunctor.wPathCasesOn_eta
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: ext (i x)
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
a : P.A
f : PFunctor.B (last P) a → PFunctor.W (last P)
h : WPath P (WType.mk a f) ⟹ α
⊢ wPathCasesOn P (wPathDestLeft P h) (wPathDestRight P h) = h

tactic: cases x <;> rfl
state_before: case a.h
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
a : P.A
f : PFunctor.B (last P) a → PFunctor.W (last P)
h : WPath P (WType.mk a f) ⟹ α
i : Fin2 n
x : WPath P (WType.mk a fun j => f j) i
⊢ wPathCasesOn P (wPathDestLeft P h) (wPathDestRight P h) i x = h i x
Theorem: Inducing.isClosed_iff'
File: Mathlib/Topology/Maps.lean

tactic: rw [hf.induced, isClosed_induced_iff']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5799
δ : Type ?u.5802
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
s : Set α
⊢ IsClosed s ↔ ∀ (x : α), f x ∈ closure (f '' s) → x ∈ s
Theorem: Convex.exists_mem_add_smul_eq
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rcases _root_.em (p = 0 ∧ q = 0) with (⟨rfl, rfl⟩ | hpq)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
p q : 𝕜
hx : x ∈ s
hy : y ∈ s
hp : 0 ≤ p
hq : 0 ≤ q
⊢ ∃ z, z ∈ s ∧ (p + q) • z = p • x + q • y

tactic: use x, hx
state_before: case inl.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
hp hq : 0 ≤ 0
⊢ ∃ z, z ∈ s ∧ (0 + 0) • z = 0 • x + 0 • y

tactic: simp
state_before: case inl.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
hp hq : 0 ≤ 0
⊢ (0 + 0) • x = 0 • x + 0 • y

tactic: replace hpq : 0 < p + q := (add_nonneg hp hq).lt_of_ne' (mt (add_eq_zero_iff' hp hq).1 hpq)
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
p q : 𝕜
hx : x ∈ s
hy : y ∈ s
hp : 0 ≤ p
hq : 0 ≤ q
hpq : ¬(p = 0 ∧ q = 0)
⊢ ∃ z, z ∈ s ∧ (p + q) • z = p • x + q • y

tactic: refine ⟨_, convex_iff_div.1 h hx hy hp hq hpq, ?_⟩
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
p q : 𝕜
hx : x ∈ s
hy : y ∈ s
hp : 0 ≤ p
hq : 0 ≤ q
hpq : 0 < p + q
⊢ ∃ z, z ∈ s ∧ (p + q) • z = p • x + q • y

tactic: simp only [smul_add, smul_smul, mul_div_cancel' _ hpq.ne']
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.262136
β : Type ?u.262139
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x y : E
p q : 𝕜
hx : x ∈ s
hy : y ∈ s
hp : 0 ≤ p
hq : 0 ≤ q
hpq : 0 < p + q
⊢ (p + q) • ((p / (p + q)) • x + (q / (p + q)) • y) = p • x + q • y
Theorem: MvPolynomial.vars_sub_subset
File: Mathlib/Data/MvPolynomial/CommRing.lean

tactic: convert vars_add_subset p (-q) using 2 <;> simp [sub_eq_add_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
⊢ vars (p - q) ⊆ vars p ∪ vars q
Theorem: Asymptotics.IsBigOWith.sub_isLittleO
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [sub_eq_add_neg] using h₁.add_isLittleO h₂.neg_left hc
state_before: α : Type u_1
β : Type ?u.224733
E : Type ?u.224736
F : Type u_3
G : Type ?u.224742
E' : Type u_2
F' : Type ?u.224748
G' : Type ?u.224751
E'' : Type ?u.224754
F'' : Type ?u.224757
G'' : Type ?u.224760
R : Type ?u.224763
R' : Type ?u.224766
𝕜 : Type ?u.224769
𝕜' : Type ?u.224772
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : IsBigOWith c₁ l f₁ g
h₂ : f₂ =o[l] g
hc : c₁ < c₂
⊢ IsBigOWith c₂ l (fun x => f₁ x - f₂ x) g
Theorem: ZFSet.map_unique
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: let ⟨w, _, we⟩ := mem_image.1 yx
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => pair z w ∈ map f x) y
⊢ y = f z

tactic: let ⟨wz, fy⟩ := pair_injective we
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => pair z w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : pair w (f w) = pair z y
⊢ y = f z

tactic: rw [← fy, wz]
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => pair z w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : pair w (f w) = pair z y
wz : w = z
fy : f w = y
⊢ y = f z
Theorem: Polynomial.coeff_zero_multiset_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: refine' Multiset.induction_on t _ fun a t ht => _
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ coeff (prod t) 0 = prod (Multiset.map (fun f => coeff f 0) t)

tactic: rw [Multiset.prod_cons, Multiset.map_cons, Multiset.prod_cons, Polynomial.mul_coeff_zero, ht]
state_before: case refine'_2
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
a : R[X]
t : Multiset R[X]
ht : coeff (prod t) 0 = prod (Multiset.map (fun f => coeff f 0) t)
⊢ coeff (prod (a ::ₘ t)) 0 = prod (Multiset.map (fun f => coeff f 0) (a ::ₘ t))

tactic: simp
state_before: case refine'_1
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ coeff (prod 0) 0 = prod (Multiset.map (fun f => coeff f 0) 0)
Theorem: Real.deriv_tan_sub_id
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

tactic: simpa using (hasDerivAt_tan h).add (hasDerivAt_id x).neg
state_before: x : ℝ
h : cos x ≠ 0
⊢ HasDerivAt (fun y => tan y - y) (↑1 / cos x ^ 2 - 1) x
Theorem: Filter.map_lift_eq
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [mem_lift_sets hg, mem_lift_sets this, exists_prop, mem_map, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort ?u.12988
f f₁ f₂ : Filter α
g g₁ g₂ : Set α → Filter β
m : β → γ
hg : Monotone g
this : Monotone (map m ∘ g)
s : Set γ
⊢ s ∈ map m (Filter.lift f g) ↔ s ∈ Filter.lift f (map m ∘ g)
Theorem: Path.delayReflRight_zero
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: ext t
state_before: X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflRight 0 γ = trans γ (refl y)

tactic: simp only [delayReflRight, trans_apply, refl_extend, Path.coe_mk_mk, Function.comp_apply,
  refl_apply]
state_before: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ ↑(delayReflRight 0 γ) t = ↑(trans γ (refl y)) t

tactic: split_ifs with h
state_before: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ ↑γ (qRight (t, 0)) = if h : ↑t ≤ 1 / 2 then ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) } else y

tactic: swap
state_before: case a.h.inl
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

case a.h.inr
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = y

tactic: conv_rhs => rw [← γ.target]
state_before: case a.h.inr
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = y

case a.h.inl
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

tactic: all_goals apply congr_arg γ; ext1; rw [qRight_zero_right]
state_before: case a.h.inr
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ 1

case a.h.inl
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

tactic: exacts [if_neg h, if_pos h]
state_before: case a.h.inr.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ (if ↑t ≤ 1 / 2 then 2 * ↑t else 1) = ↑1

case a.h.inl.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ (if ↑t ≤ 1 / 2 then 2 * ↑t else 1) = ↑{ val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

tactic: apply congr_arg γ
state_before: case a.h.inl
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

tactic: ext1
state_before: case a.h.inl
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ qRight (t, 0) = { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

tactic: rw [qRight_zero_right]
state_before: case a.h.inl.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑(qRight (t, 0)) = ↑{ val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
Theorem: Orthonormal.inner_finsupp_eq_sum_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [l₁.total_apply _, Finsupp.sum_inner, hv.inner_right_finsupp, smul_eq_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2023925
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l₁ l₂ : ι →₀ 𝕜
⊢ inner (↑(Finsupp.total ι E 𝕜 v) l₁) (↑(Finsupp.total ι E 𝕜 v) l₂) =
    Finsupp.sum l₁ fun i y => ↑(starRingEnd 𝕜) y * ↑l₂ i
Theorem: Stream'.even_interleave
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h₁]
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = even (s₁ ⋈ s₂)
⊢ head s₁' = head s₁ ∧ (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) (tail s₁') (tail s₁)

tactic: constructor
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = even (s₁ ⋈ s₂)
⊢ head (even (s₁ ⋈ s₂)) = head s₁ ∧ (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) (tail (even (s₁ ⋈ s₂))) (tail s₁)

tactic: rfl
state_before: case left
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = even (s₁ ⋈ s₂)
⊢ head (even (s₁ ⋈ s₂)) = head s₁

tactic: exact ⟨tail s₂, by rw [interleave_eq, even_cons_cons, tail_cons]⟩
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = even (s₁ ⋈ s₂)
⊢ (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) (tail (even (s₁ ⋈ s₂))) (tail s₁)

tactic: rw [interleave_eq, even_cons_cons, tail_cons]
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = even (s₁ ⋈ s₂)) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = even (s₁ ⋈ s₂)
⊢ tail (even (s₁ ⋈ s₂)) = even (tail s₁ ⋈ tail s₂)
Theorem: Nat.lcm_ne_zero
File: Std/Data/Nat/Gcd.lean

tactic: intro h
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
⊢ lcm m n ≠ 0

tactic: have h1 := gcd_mul_lcm m n
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
h : lcm m n = 0
⊢ False

tactic: rw [h, Nat.mul_zero] at h1
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
h : lcm m n = 0
h1 : gcd m n * lcm m n = m * n
⊢ False

tactic: match mul_eq_zero.1 h1.symm with
| .inl hm1 => exact hm hm1
| .inr hn1 => exact hn hn1
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
h : lcm m n = 0
h1 : 0 = m * n
⊢ False

tactic: exact hm hm1
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
h : lcm m n = 0
h1 : 0 = m * n
hm1 : m = 0
⊢ False

tactic: exact hn hn1
state_before: m n : Nat
hm : m ≠ 0
hn : n ≠ 0
h : lcm m n = 0
h1 : 0 = m * n
hn1 : n = 0
⊢ False
Theorem: CategoryTheory.Limits.biprod.map_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: apply biprod.hom_ext <;> apply biprod.hom_ext' <;> simp
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : Preadditive C
J : Type
inst✝² : Fintype J
X✝ Y✝ : C
inst✝¹ : HasBinaryBiproduct X✝ Y✝
inst✝ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
⊢ map f g = fst ≫ f ≫ inl + snd ≫ g ≫ inr