tasksource/leandojo huggingface dataset:
Theorem: Polynomial.map_roots_le
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [count_roots]
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ Multiset.count b (roots (map f p))

tactic: apply count_map_roots h
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (↑f) (roots p)) ≤ rootMultiplicity b (map f p)
Theorem: SimpleGraph.deleteEdges_empty_eq
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext
state_before: ι : Sort ?u.156154
𝕜 : Type ?u.156157
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
⊢ deleteEdges G ∅ = G

tactic: simp
state_before: case Adj.h.h.a
ι : Sort ?u.156154
𝕜 : Type ?u.156157
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
x✝¹ x✝ : V
⊢ Adj (deleteEdges G ∅) x✝¹ x✝ ↔ Adj G x✝¹ x✝
Theorem: LaurentPolynomial.induction_on'
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: refine' p.induction_on (fun a => _) (fun {p q} => h_add p q) _ _ <;>
    try exact fun n f _ => h_C_mul_T _ f
state_before: R : Type u_1
inst✝ : Semiring R
M : R[T;T⁻¹] → Prop
p : R[T;T⁻¹]
h_add : ∀ (p q : R[T;T⁻¹]), M p → M q → M (p + q)
h_C_mul_T : ∀ (n : ℤ) (a : R), M (↑C a * T n)
⊢ M p

tactic: convert h_C_mul_T 0 a
state_before: case refine'_1
R : Type u_1
inst✝ : Semiring R
M : R[T;T⁻¹] → Prop
p : R[T;T⁻¹]
h_add : ∀ (p q : R[T;T⁻¹]), M p → M q → M (p + q)
h_C_mul_T : ∀ (n : ℤ) (a : R), M (↑C a * T n)
a : R
⊢ M (↑C a)

tactic: exact (mul_one _).symm
state_before: case h.e'_1
R : Type u_1
inst✝ : Semiring R
M : R[T;T⁻¹] → Prop
p : R[T;T⁻¹]
h_add : ∀ (p q : R[T;T⁻¹]), M p → M q → M (p + q)
h_C_mul_T : ∀ (n : ℤ) (a : R), M (↑C a * T n)
a : R
⊢ ↑C a = ↑C a * T 0

tactic: exact fun n f _ => h_C_mul_T _ f
state_before: case refine'_3
R : Type u_1
inst✝ : Semiring R
M : R[T;T⁻¹] → Prop
p : R[T;T⁻¹]
h_add : ∀ (p q : R[T;T⁻¹]), M p → M q → M (p + q)
h_C_mul_T : ∀ (n : ℤ) (a : R), M (↑C a * T n)
⊢ ∀ (n : ℕ) (a : R), M (↑C a * T (-↑n)) → M (↑C a * T (-↑n - 1))
Theorem: eq_div_iff_mul_eq''
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [eq_div_iff_mul_eq', mul_comm]
state_before: α : Type ?u.70975
β : Type ?u.70978
G : Type u_1
inst✝ : CommGroup G
a b c d : G
⊢ a = b / c ↔ c * a = b
Theorem: Metric.uniformity_eq_comap_nhds_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext s
state_before: α : Type u
β : Type v
X : Type ?u.203876
ι : Type ?u.203879
inst✝ : PseudoMetricSpace α
⊢ 𝓤 α = comap (fun p => dist p.fst p.snd) (𝓝 0)

tactic: simp only [mem_uniformity_dist, (nhds_basis_ball.comap _).mem_iff]
state_before: case a
α : Type u
β : Type v
X : Type ?u.203876
ι : Type ?u.203879
inst✝ : PseudoMetricSpace α
s : Set (α × α)
⊢ s ∈ 𝓤 α ↔ s ∈ comap (fun p => dist p.fst p.snd) (𝓝 0)

tactic: simp [subset_def, Real.dist_0_eq_abs]
state_before: case a
α : Type u
β : Type v
X : Type ?u.203876
ι : Type ?u.203879
inst✝ : PseudoMetricSpace α
s : Set (α × α)
⊢ (∃ ε, ε > 0 ∧ ∀ {a b : α}, dist a b < ε → (a, b) ∈ s) ↔ ∃ i, 0 < i ∧ (fun p => dist p.fst p.snd) ⁻¹' ball 0 i ⊆ s
Theorem: Polynomial.leadingCoeff_eq_zero_iff_deg_eq_bot
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [leadingCoeff_eq_zero, degree_eq_bot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.514960
⊢ leadingCoeff p = 0 ↔ degree p = ⊥
Theorem: List.of_concat_eq_concat
File: src/lean/Init/Data/List/Basic.lean

tactic: match as, bs with
| [], [] => simp [concat] at h; simp [h]
| [_], [] => simp [concat] at h
| _::_::_, [] => simp [concat] at h
| [], [_] => simp [concat] at h
| [], _::_::_ => simp [concat] at h
| _::_, _::_ => simp [concat] at h; simp [h]; apply of_concat_eq_concat h.2
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b : α
h : concat as a = concat bs b
⊢ as = bs ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b : α
h : concat nil a = concat nil b
⊢ nil = nil ∧ a = b

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b : α
h : a = b
⊢ nil = nil ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝ : α
h : concat (head✝ :: nil) a = concat nil b
⊢ head✝ :: nil = nil ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝¹ head✝ : α
tail✝ : List α
h : concat (head✝¹ :: head✝ :: tail✝) a = concat nil b
⊢ head✝¹ :: head✝ :: tail✝ = nil ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝ : α
h : concat nil a = concat (head✝ :: nil) b
⊢ nil = head✝ :: nil ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝¹ head✝ : α
tail✝ : List α
h : concat nil a = concat (head✝¹ :: head✝ :: tail✝) b
⊢ nil = head✝¹ :: head✝ :: tail✝ ∧ a = b

tactic: simp [concat] at h
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝¹ : α
tail✝¹ : List α
head✝ : α
tail✝ : List α
h : concat (head✝¹ :: tail✝¹) a = concat (head✝ :: tail✝) b
⊢ head✝¹ :: tail✝¹ = head✝ :: tail✝ ∧ a = b

tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝¹ : α
tail✝¹ : List α
head✝ : α
tail✝ : List α
h : head✝¹ = head✝ ∧ concat tail✝¹ a = concat tail✝ b
⊢ head✝¹ :: tail✝¹ = head✝ :: tail✝ ∧ a = b

tactic: apply of_concat_eq_concat h.2
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
a b head✝¹ : α
tail✝¹ : List α
head✝ : α
tail✝ : List α
h : head✝¹ = head✝ ∧ concat tail✝¹ a = concat tail✝ b
⊢ tail✝¹ = tail✝ ∧ a = b
Theorem: ZNum.to_of_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp
state_before: α : Type ?u.1062538
n : ℤ
⊢ ↑↑0 = 0

tactic: simp
state_before: α : Type ?u.1062538
n : ℤ
⊢ ∀ (k : ℤ), 0 ≤ k → ↑↑k = k → ↑↑(k + 1) = k + 1

tactic: simp
state_before: α : Type ?u.1062538
n : ℤ
⊢ ∀ (k : ℤ), k ≤ 0 → ↑↑k = k → ↑↑(k - 1) = k - 1
Theorem: MeasureTheory.Measure.withDensity_rnDeriv_le
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hl : HaveLebesgueDecomposition μ ν
state_before: α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ withDensity ν (rnDeriv μ ν) ≤ μ

tactic: cases' (haveLebesgueDecomposition_spec μ ν).2 with _ h
state_before: case pos
α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : HaveLebesgueDecomposition μ ν
⊢ withDensity ν (rnDeriv μ ν) ≤ μ

tactic: conv_rhs => rw [h]
state_before: case pos.intro
α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : HaveLebesgueDecomposition μ ν
left✝ : singularPart μ ν ⟂ₘ ν
h : μ = singularPart μ ν + withDensity ν (rnDeriv μ ν)
⊢ withDensity ν (rnDeriv μ ν) ≤ μ

tactic: exact Measure.le_add_left le_rfl
state_before: case pos.intro
α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : HaveLebesgueDecomposition μ ν
left✝ : singularPart μ ν ⟂ₘ ν
h : μ = singularPart μ ν + withDensity ν (rnDeriv μ ν)
⊢ withDensity ν (rnDeriv μ ν) ≤ singularPart μ ν + withDensity ν (rnDeriv μ ν)

tactic: rw [rnDeriv, dif_neg hl, withDensity_zero]
state_before: case neg
α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬HaveLebesgueDecomposition μ ν
⊢ withDensity ν (rnDeriv μ ν) ≤ μ

tactic: exact Measure.zero_le μ
state_before: case neg
α : Type u_1
β : Type ?u.34335
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
hl : ¬HaveLebesgueDecomposition μ ν
⊢ 0 ≤ μ
Theorem: IsSMulRegular.of_smul_eq_one
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rw [h]
state_before: R : Type u_2
S : Type u_1
M : Type u_3
a b : R
s : S
inst✝⁴ : Monoid S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : MulAction S M
inst✝ : IsScalarTower R S M
h : a • s = 1
⊢ IsSMulRegular M (a • s)

tactic: exact one M
state_before: R : Type u_2
S : Type u_1
M : Type u_3
a b : R
s : S
inst✝⁴ : Monoid S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : MulAction S M
inst✝ : IsScalarTower R S M
h : a • s = 1
⊢ IsSMulRegular M 1
Theorem: Matrix.equiv_block_det
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: convert Matrix.det_reindex_self (Equiv.subtypeEquivRight e) (toSquareBlockProp M q)
state_before: α : Type ?u.40762
β : Type ?u.40765
m : Type u_1
n : Type ?u.40771
o : Type ?u.40774
m' : α → Type ?u.40779
n' : α → Type ?u.40784
R : Type v
inst✝⁶ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁵ : DecidableEq m
inst✝⁴ : Fintype m
inst✝³ : DecidableEq n
inst✝² : Fintype n
M : Matrix m m R
p q : m → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : ∀ (x : m), q x ↔ p x
⊢ det (toSquareBlockProp M p) = det (toSquareBlockProp M q)
Theorem: Finset.subset_product_image_snd
File: Mathlib/Data/Finset/Prod.lean

tactic: simp (config := { contextual := true }) [mem_image]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.6733
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
i : β
⊢ i ∈ image Prod.snd (s ×ˢ t) → i ∈ t
Theorem: not_bddAbove_univ
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [BddAbove]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : NoMaxOrder α
⊢ ¬BddAbove univ
Theorem: linearDependent_comp_subtype'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [linearIndependent_comp_subtype, and_left_comm]
state_before: ι : Type u'
ι' : Type ?u.174501
R : Type u_1
K : Type ?u.174507
M : Type u_2
M' : Type ?u.174513
M'' : Type ?u.174516
V : Type u
V' : Type ?u.174521
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set ι
⊢ ¬LinearIndependent R (v ∘ Subtype.val) ↔ ∃ f, f ∈ Finsupp.supported R R s ∧ ↑(Finsupp.total ι M R v) f = 0 ∧ f ≠ 0
Theorem: Set.Nonempty.eq_univ
File: Mathlib/Data/Set/Basic.lean

tactic: rintro ⟨x, hx⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
⊢ Set.Nonempty s → s = univ

tactic: refine' eq_univ_of_forall fun y => by rwa [Subsingleton.elim y x]
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
⊢ s = univ

tactic: rwa [Subsingleton.elim y x]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Subsingleton α
x : α
hx : x ∈ s
y : α
⊢ y ∈ s
Theorem: Submodule.mem_sup'
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp only [Subtype.exists, exists_prop]
state_before: R : Type u_2
R₂ : Type ?u.100784
K : Type ?u.100787
M : Type u_1
M₂ : Type ?u.100793
V : Type ?u.100796
S : Type ?u.100799
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ (∃ y, y ∈ p ∧ ∃ z, z ∈ p' ∧ y + z = x) ↔ ∃ y z, ↑y + ↑z = x
Theorem: Filter.Tendsto.div_atTop
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: simp only [div_eq_mul_inv]
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
a : 𝕜
h : Tendsto f l (𝓝 a)
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x / g x) l (𝓝 0)

tactic: exact mul_zero a ▸ h.mul (tendsto_inv_atTop_zero.comp hg)
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
a : 𝕜
h : Tendsto f l (𝓝 a)
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x * (g x)⁻¹) l (𝓝 0)
Theorem: Lagrange.eval_nodal_not_at_node
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [nodal, eval_prod, prod_ne_zero_iff, eval_sub, eval_X, eval_C, sub_ne_zero]
state_before: F : Type u_2
inst✝ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ eval x (nodal s v) ≠ 0

tactic: exact hx
state_before: F : Type u_2
inst✝ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ ∀ (a : ι), a ∈ s → x ≠ v a
Theorem: StrictConvexOn.secant_strict_mono_aux3
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have hyz' : 0 < z - y := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)

tactic: have hxz' : 0 < z - x := by linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)

tactic: rw [div_lt_div_iff hxz' hyz']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) / (z - x) < (f z - f y) / (z - y)

tactic: linarith only [hf.secant_strict_mono_aux1 hx hz hxy hyz]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
hxz' : 0 < z - x
⊢ (f z - f x) * (z - y) < (f z - f y) * (z - x)

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ 0 < z - y

tactic: linarith
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
hyz' : 0 < z - y
⊢ 0 < z - x
Theorem: linearIndependent_fin_succ
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [← linearIndependent_fin_cons, Fin.cons_self_tail]
state_before: ι : Type u'
ι' : Type ?u.1249118
R : Type ?u.1249121
K : Type u_1
M : Type ?u.1249127
M' : Type ?u.1249130
M'' : Type ?u.1249133
V : Type u
V' : Type ?u.1249138
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
n : ℕ
v : Fin (n + 1) → V
⊢ LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ ¬v 0 ∈ span K (range (Fin.tail v))
Theorem: List.countp_pos
File: Mathlib/Data/List/Count.lean

tactic: simp only [countp_eq_length_filter, length_pos_iff_exists_mem, mem_filter, exists_prop]
state_before: α : Type u_1
l : List α
p q : α → Bool
⊢ 0 < countp p l ↔ ∃ a, a ∈ l ∧ p a = true
Theorem: Nat.binomial_eq_choose
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simp [binomial_eq _ h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : a ≠ b
⊢ multinomial {a, b} f = choose (f a + f b) (f a)
Theorem: List.Chain'.two_mul_count_bool_of_even
File: Mathlib/Data/Bool/Count.lean

tactic: rw [← count_not_add_count l b, hl.count_not_eq_count h2, two_mul]
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
h2 : Even (length l)
b : Bool
⊢ 2 * count b l = length l
Theorem: SimplexCategory.image_ι_eq
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: haveI := strongEpi_of_epi e
state_before: Δ Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ image φ
inst✝¹ : Epi e
i : image φ ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
⊢ image.ι φ = i

tactic: rw [← image.isoStrongEpiMono_hom_comp_ι e i fac,
  SimplexCategory.eq_id_of_isIso (image.isoStrongEpiMono e i fac).hom, Category.id_comp]
state_before: Δ Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ image φ
inst✝¹ : Epi e
i : image φ ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
this : StrongEpi e
⊢ image.ι φ = i
Theorem: ContinuousInv.of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: refine' ⟨continuous_iff_continuousAt.2 fun x₀ => _⟩
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝¹ : Group G
inst✝ : TopologicalSpace G
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
hconj : ∀ (x₀ : G), Tendsto (fun x => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)
⊢ ContinuousInv G
Theorem: Submonoid.closure_singleton_one
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: simp [eq_bot_iff_forall, mem_closure_singleton]
state_before: M : Type u_1
A : Type ?u.72862
B : Type ?u.72865
inst✝ : Monoid M
⊢ closure {1} = ⊥
Theorem: Std.RBNode.Stream.next?_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: cases s <;> simp [next?, toStream_toList']
state_before: α : Type u_1
s : RBNode.Stream α
⊢ Option.map
      (fun x =>
        match x with
        | (a, b) => (a, toList b))
      (next? s) =
    List.next? (toList s)
Theorem: starConvex_iff_div
File: Mathlib/Analysis/Convex/Star.lean

tactic: apply h hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ (a / (a + b)) • x + (b / (a + b)) • y ∈ s

tactic: positivity
state_before: case a
𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ 0 ≤ a / (a + b)

tactic: positivity
state_before: case a
𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ 0 ≤ b / (a + b)

tactic: rw [← add_div]
state_before: case a
𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ a / (a + b) + b / (a + b) = 1

tactic: exact div_self hab.ne'
state_before: case a
𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : 0 < a + b
⊢ (a + b) / (a + b) = 1

tactic: have h' := h hy ha hb
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ s

tactic: rw [hab, div_one, div_one] at h'
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h' : 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
⊢ a • x + b • y ∈ s

tactic: exact h' zero_lt_one
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.140518
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
h : ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h' : 0 < 1 → a • x + b • y ∈ s
⊢ a • x + b • y ∈ s
Theorem: gcd_isUnit_iff
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: rw [IsCoprime, ← Ideal.mem_span_pair, ← span_gcd, ← span_singleton_eq_top, eq_top_iff_one]
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
⊢ IsUnit (gcd x y) ↔ IsCoprime x y
Theorem: commutator_eq_normalClosure
File: Mathlib/GroupTheory/Abelianization.lean

tactic: simp [commutator, Subgroup.commutator_def', commutatorSet]
state_before: G : Type u
inst✝ : Group G
⊢ commutator G = Subgroup.normalClosure (commutatorSet G)
Theorem: CategoryTheory.Presieve.singleton_eq_iff_domain
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: constructor
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ f g : Y ⟶ X
⊢ singleton f g ↔ f = g

tactic: rintro ⟨a, rfl⟩
state_before: case mp
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ f g : Y ⟶ X
⊢ singleton f g → f = g

tactic: rfl
state_before: case mp.mk
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y✝ Z : C
f✝ f : Y✝ ⟶ X
Y : C
⊢ f = f

tactic: rintro rfl
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ f g : Y ⟶ X
⊢ f = g → singleton f g

tactic: apply singleton.mk
state_before: case mpr
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ f : Y ⟶ X
⊢ singleton f f
Theorem: WittVector.constantCoeff_wittAdd
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type ?u.75316
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (wittAdd p n) = 0

tactic: simp only [add_zero, RingHom.map_add, constantCoeff_X]
state_before: p : ℕ
R : Type ?u.75316
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (X 0 + X 1) = 0
Theorem: nhds_eq_uniformity_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [nhds_prod_eq, nhds_nhds_eq_uniformity_uniformity_prod, lift_lift'_same_eq_lift']
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78723
inst✝ : UniformSpace α
a b : α
⊢ 𝓝 (a, b) = Filter.lift' (𝓤 α) fun s => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ s}

tactic: exact fun s => monotone_const.set_prod monotone_preimage
state_before: case hg₁
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78723
inst✝ : UniformSpace α
a b : α
⊢ ∀ (s : Set (α × α)), Monotone fun t => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ t}

tactic: refine fun t => Monotone.set_prod ?_ monotone_const
state_before: case hg₂
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78723
inst✝ : UniformSpace α
a b : α
⊢ ∀ (t : Set (α × α)), Monotone fun s => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ t}

tactic: exact monotone_preimage (f := fun y => (y, a))
state_before: case hg₂
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.78723
inst✝ : UniformSpace α
a b : α
t : Set (α × α)
⊢ Monotone fun s => {y | (y, a) ∈ s}
Theorem: smul_one_mul
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [smul_mul_assoc, one_mul]
state_before: M✝ : Type ?u.27123
N✝ : Type ?u.27126
G : Type ?u.27129
A : Type ?u.27132
B : Type ?u.27135
α : Type ?u.27138
β : Type ?u.27141
γ : Type ?u.27144
δ : Type ?u.27147
M : Type u_1
N : Type u_2
inst✝² : MulOneClass N
inst✝¹ : SMul M N
inst✝ : IsScalarTower M N N
x : M
y : N
⊢ x • 1 * y = x • y
Theorem: finrank_range_le_card
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [Set.toFinset_range]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Finset.card (Set.toFinset (Set.range b)) ≤ Fintype.card ι

tactic: exact Finset.card_image_le
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
⊢ Finset.card (Finset.image b Finset.univ) ≤ Fintype.card ι