tasksource/leandojo huggingface dataset:
Theorem: TopologicalSpace.isSeparable_of_separableSpace_subtype
File: Mathlib/Topology/Bases.lean

tactic: have : IsSeparable (((↑) : s → α) '' (univ : Set s)) :=
  (isSeparable_of_separableSpace _).image continuous_subtype_val
state_before: α : Type u
t : TopologicalSpace α
s : Set α
inst✝ : SeparableSpace ↑s
⊢ IsSeparable s

tactic: simpa only [image_univ, Subtype.range_val_subtype] using this
state_before: α : Type u
t : TopologicalSpace α
s : Set α
inst✝ : SeparableSpace ↑s
this : IsSeparable (Subtype.val '' univ)
⊢ IsSeparable s
Theorem: CategoryTheory.Limits.terminal.comp_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : HasTerminal C
P Q : C
f : P ⟶ Q
⊢ f ≫ from Q = from P
Theorem: Polynomial.C_bit1
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp [bit1, C_bit0]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ↑C (bit1 a) = bit1 (↑C a)
Theorem: ENorm.map_sub_le
File: Mathlib/Analysis/NormedSpace/ENorm.lean

tactic: rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x y : V
⊢ ↑e (x - y) = ↑e (x + -y)

tactic: rw [e.map_neg]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x y : V
⊢ ↑e x + ↑e (-y) = ↑e x + ↑e y
Theorem: MvPolynomial.degrees_monomial
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
  refine' Finset.sup_le fun t h => _
  have := Finsupp.support_single_subset h
  rw [Finset.mem_singleton] at this
  rw [this]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.3088
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ degrees (↑(monomial s) a) ≤ ↑toMultiset s

tactic: refine' Finset.sup_le fun t h => _
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.3088
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
⊢ degrees (↑(monomial s) a) ≤ ↑toMultiset s

tactic: have := Finsupp.support_single_subset h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.3088
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
t : σ →₀ ℕ
h : t ∈ support (↑(monomial s) a)
⊢ ↑toMultiset t ≤ ↑toMultiset s

tactic: rw [Finset.mem_singleton] at this
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.3088
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
t : σ →₀ ℕ
h : t ∈ support (↑(monomial s) a)
this : t ∈ {s}
⊢ ↑toMultiset t ≤ ↑toMultiset s

tactic: rw [this]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.3088
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
a : R
t : σ →₀ ℕ
h : t ∈ support (↑(monomial s) a)
this : t = s
⊢ ↑toMultiset t ≤ ↑toMultiset s
Theorem: Function.mulSupport_iSup
File: Mathlib/Algebra/Support.lean

tactic: rw [mulSupport_subset_iff']
state_before: α : Type u_3
β : Type ?u.13009
A : Type ?u.13012
B : Type ?u.13015
M : Type u_1
N : Type ?u.13021
P : Type ?u.13024
R : Type ?u.13027
S : Type ?u.13030
G : Type ?u.13033
M₀ : Type ?u.13036
G₀ : Type ?u.13039
ι : Sort u_2
inst✝⁴ : One M
inst✝³ : One N
inst✝² : One P
inst✝¹ : ConditionallyCompleteLattice M
inst✝ : Nonempty ι
f : ι → α → M
⊢ (mulSupport fun x => ⨆ (i : ι), f i x) ⊆ ⋃ (i : ι), mulSupport (f i)

tactic: simp only [mem_iUnion, not_exists, nmem_mulSupport]
state_before: α : Type u_3
β : Type ?u.13009
A : Type ?u.13012
B : Type ?u.13015
M : Type u_1
N : Type ?u.13021
P : Type ?u.13024
R : Type ?u.13027
S : Type ?u.13030
G : Type ?u.13033
M₀ : Type ?u.13036
G₀ : Type ?u.13039
ι : Sort u_2
inst✝⁴ : One M
inst✝³ : One N
inst✝² : One P
inst✝¹ : ConditionallyCompleteLattice M
inst✝ : Nonempty ι
f : ι → α → M
⊢ ∀ (x : α), (¬x ∈ ⋃ (i : ι), mulSupport (f i)) → (⨆ (i : ι), f i x) = 1

tactic: intro x hx
state_before: α : Type u_3
β : Type ?u.13009
A : Type ?u.13012
B : Type ?u.13015
M : Type u_1
N : Type ?u.13021
P : Type ?u.13024
R : Type ?u.13027
S : Type ?u.13030
G : Type ?u.13033
M₀ : Type ?u.13036
G₀ : Type ?u.13039
ι : Sort u_2
inst✝⁴ : One M
inst✝³ : One N
inst✝² : One P
inst✝¹ : ConditionallyCompleteLattice M
inst✝ : Nonempty ι
f : ι → α → M
⊢ ∀ (x : α), (∀ (x_1 : ι), f x_1 x = 1) → (⨆ (i : ι), f i x) = 1

tactic: simp only [hx, ciSup_const]
state_before: α : Type u_3
β : Type ?u.13009
A : Type ?u.13012
B : Type ?u.13015
M : Type u_1
N : Type ?u.13021
P : Type ?u.13024
R : Type ?u.13027
S : Type ?u.13030
G : Type ?u.13033
M₀ : Type ?u.13036
G₀ : Type ?u.13039
ι : Sort u_2
inst✝⁴ : One M
inst✝³ : One N
inst✝² : One P
inst✝¹ : ConditionallyCompleteLattice M
inst✝ : Nonempty ι
f : ι → α → M
x : α
hx : ∀ (x_1 : ι), f x_1 x = 1
⊢ (⨆ (i : ι), f i x) = 1
Theorem: Int.ofNat_dvd_left
File: Std/Data/Int/DivMod.lean

tactic: rw [← natAbs_dvd_natAbs, natAbs_ofNat]
state_before: n : Nat
z : Int
⊢ ↑n ∣ z ↔ n ∣ natAbs z
Theorem: padicNorm.nonarchimedean
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: wlog hle : padicValRat p q ≤ padicValRat p r generalizing q r
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)

tactic: exact nonarchimedean_aux hle
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hle : padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)

tactic: rw [add_comm, max_comm]
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
this : ∀ {q r : ℚ}, padicValRat p q ≤ padicValRat p r → padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
hle : ¬padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)

tactic: exact this (le_of_not_le hle)
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
this : ∀ {q r : ℚ}, padicValRat p q ≤ padicValRat p r → padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
hle : ¬padicValRat p q ≤ padicValRat p r
⊢ padicNorm p (r + q) ≤ max (padicNorm p r) (padicNorm p q)
Theorem: LinearMap.mul_toMatrix'
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp only [B.toMatrix₂'_comp, transpose_transpose, toMatrix'_toLin']
state_before: R : Type u_1
R₁ : Type ?u.1026117
R₂ : Type ?u.1026120
M✝ : Type ?u.1026123
M₁ : Type ?u.1026126
M₂ : Type ?u.1026129
M₁' : Type ?u.1026132
M₂' : Type ?u.1026135
n : Type u_2
m : Type u_3
n' : Type u_4
m' : Type ?u.1026147
ι : Type ?u.1026150
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'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
M : Matrix n' n R
⊢ M ⬝ ↑toMatrix₂' B = ↑toMatrix₂' (comp B (↑toLin' Mᵀ))
Theorem: Set.div_mem_centralizer₀
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : GroupWithZero M
ha : a ∈ centralizer S
hb : b ∈ centralizer S
⊢ a / b ∈ centralizer S

tactic: exact mul_mem_centralizer ha (inv_mem_centralizer₀ hb)
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : GroupWithZero M
ha : a ∈ centralizer S
hb : b ∈ centralizer S
⊢ a * b⁻¹ ∈ centralizer S
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_union
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [h₁ t, h₂ (t ∩ s₁), h₂ (t \ s₁), h₁ (t ∩ (s₁ ∪ s₂)), inter_diff_assoc _ _ s₁,
  Set.inter_assoc _ _ s₁, inter_eq_self_of_subset_right (Set.subset_union_left _ _),
  union_diff_left, h₂ (t ∩ s₁)]
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h₁ : IsCaratheodory m s₁
h₂ : IsCaratheodory m s₂
t : Set α
⊢ ↑m t = ↑m (t ∩ (s₁ ∪ s₂)) + ↑m (t \ (s₁ ∪ s₂))

tactic: simp [diff_eq, add_assoc]
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h₁ : IsCaratheodory m s₁
h₂ : IsCaratheodory m s₂
t : Set α
⊢ ↑m (t ∩ s₁ ∩ s₂) + ↑m ((t ∩ s₁) \ s₂) + (↑m (t \ s₁ ∩ s₂) + ↑m ((t \ s₁) \ s₂)) =
    ↑m (t ∩ s₁ ∩ s₂) + ↑m ((t ∩ s₁) \ s₂) + ↑m (t ∩ (s₂ \ s₁)) + ↑m (t \ (s₁ ∪ s₂))
Theorem: List.nthLe_reverse'
File: Mathlib/Data/List/Basic.lean

tactic: rw [eq_comm]
state_before: ι : Type ?u.97720
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
hn : n < length (reverse l)
hn' : length l - 1 - n < length l
⊢ nthLe (reverse l) n hn = nthLe l (length l - 1 - n) hn'

tactic: convert nthLe_reverse l.reverse n (by simpa) hn using 1
state_before: ι : Type ?u.97720
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
hn : n < length (reverse l)
hn' : length l - 1 - n < length l
⊢ nthLe l (length l - 1 - n) hn' = nthLe (reverse l) n hn

tactic: simp
state_before: case h.e'_2
ι : Type ?u.97720
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
hn : n < length (reverse l)
hn' : length l - 1 - n < length l
⊢ nthLe l (length l - 1 - n) hn' =
    nthLe (reverse (reverse l)) (length (reverse l) - 1 - n)
      (_ : length (reverse l) - 1 - n < length (reverse (reverse l)))

tactic: simpa
state_before: ι : Type ?u.97720
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
hn : n < length (reverse l)
hn' : length l - 1 - n < length l
⊢ length (reverse l) - 1 - n < length (reverse (reverse l))
Theorem: Set.inv_mem_center₀
File: Mathlib/GroupTheory/Subsemigroup/Center.lean

tactic: obtain rfl | ha0 := eq_or_ne a 0
state_before: M : Type u_1
inst✝ : GroupWithZero M
a : M
ha : a ∈ center M
⊢ a⁻¹ ∈ center M

tactic: rcases IsUnit.mk0 _ ha0 with ⟨a, rfl⟩
state_before: case inr
M : Type u_1
inst✝ : GroupWithZero M
a : M
ha : a ∈ center M
ha0 : a ≠ 0
⊢ a⁻¹ ∈ center M

tactic: rw [← Units.val_inv_eq_inv_val]
state_before: case inr.intro
M : Type u_1
inst✝ : GroupWithZero M
a : Mˣ
ha : ↑a ∈ center M
ha0 : ↑a ≠ 0
⊢ (↑a)⁻¹ ∈ center M

tactic: exact center_units_subset (inv_mem_center (subset_center_units ha))
state_before: case inr.intro
M : Type u_1
inst✝ : GroupWithZero M
a : Mˣ
ha : ↑a ∈ center M
ha0 : ↑a ≠ 0
⊢ ↑a⁻¹ ∈ center M

tactic: rw [inv_zero]
state_before: case inl
M : Type u_1
inst✝ : GroupWithZero M
ha : 0 ∈ center M
⊢ 0⁻¹ ∈ center M

tactic: exact zero_mem_center M
state_before: case inl
M : Type u_1
inst✝ : GroupWithZero M
ha : 0 ∈ center M
⊢ 0 ∈ center M
Theorem: toIcoMod_eventuallyEq_toIocMod
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: rw [Ico_eq_locus_Ioc_eq_iUnion_Ioo]
state_before: 𝕜 : Type u_1
B : Type ?u.15815
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen {x | (fun x => toIcoMod hp a x = toIocMod hp a x) x}

tactic: exact isOpen_iUnion fun i => isOpen_Ioo
state_before: 𝕜 : Type u_1
B : Type ?u.15815
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen (⋃ (z : ℤ), Ioo (a + z • p) (a + p + z • p))
Theorem: SimpleGraph.Subgraph.comap_monotone
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: intro H H' h
state_before: ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
⊢ Monotone (Subgraph.comap f)

tactic: constructor
state_before: ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
⊢ Subgraph.comap f H ≤ Subgraph.comap f H'

tactic: intro
state_before: case left
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
⊢ (Subgraph.comap f H).verts ⊆ (Subgraph.comap f H').verts

tactic: simp only [comap_verts, Set.mem_preimage]
state_before: case left
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
a✝ : V
⊢ a✝ ∈ (Subgraph.comap f H).verts → a✝ ∈ (Subgraph.comap f H').verts

tactic: apply h.1
state_before: case left
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
a✝ : V
⊢ ↑f a✝ ∈ H.verts → ↑f a✝ ∈ H'.verts

tactic: intro v w
state_before: case right
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
⊢ ∀ ⦃v w : V⦄, Adj (Subgraph.comap f H) v w → Adj (Subgraph.comap f H') v w

tactic: simp (config := { contextual := true }) only [comap_Adj, and_imp, true_and_iff]
state_before: case right
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
v w : V
⊢ Adj (Subgraph.comap f H) v w → Adj (Subgraph.comap f H') v w

tactic: intro
state_before: case right
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
v w : V
⊢ SimpleGraph.Adj G v w → Adj H (↑f v) (↑f w) → Adj H' (↑f v) (↑f w)

tactic: apply h.2
state_before: case right
ι : Sort ?u.167405
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : SimpleGraph W
f : G →g G'
H H' : Subgraph G'
h : H ≤ H'
v w : V
a✝ : SimpleGraph.Adj G v w
⊢ Adj H (↑f v) (↑f w) → Adj H' (↑f v) (↑f w)
Theorem: Multiplicative.isSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

tactic: rintro ⟨⟨h₁, h₂⟩, h₃⟩
state_before: G : Type ?u.3681
H : Type ?u.3684
A : Type u_1
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
⊢ IsSubgroup s → IsAddSubgroup s

tactic: exact @IsAddSubgroup.mk A _ _ ⟨h₁, @h₂⟩ @h₃
state_before: case mk.mk
G : Type ?u.3681
H : Type ?u.3684
A : Type u_1
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set A
h₃ : ∀ {a : Multiplicative A}, a ∈ s → a⁻¹ ∈ s
h₁ : 1 ∈ s
h₂ : ∀ {a b : Multiplicative A}, a ∈ s → b ∈ s → a * b ∈ s
⊢ IsAddSubgroup s
Theorem: Nat.Linear.PolyCnstr.eq_true_of_isValid
File: src/lean/Init/Data/Nat/Linear.lean

tactic: cases c
state_before: ctx : Context
c : PolyCnstr
⊢ isValid c = true → denote ctx c = True

tactic: rename_i eq lhs rhs
state_before: case mk
ctx : Context
eq✝ : Bool
lhs✝ rhs✝ : Poly
⊢ isValid { eq := eq✝, lhs := lhs✝, rhs := rhs✝ } = true → denote ctx { eq := eq✝, lhs := lhs✝, rhs := rhs✝ } = True

tactic: simp [isValid]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Poly
⊢ isValid { eq := eq, lhs := lhs, rhs := rhs } = true → denote ctx { eq := eq, lhs := lhs, rhs := rhs } = True

tactic: by_cases he : eq = true <;> simp [he, denote, Poly.denote_eq, Poly.denote_le]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Poly
⊢ (bif eq then Poly.isZero lhs && Poly.isZero rhs else Poly.isZero lhs) = true →
    denote ctx { eq := eq, lhs := lhs, rhs := rhs } = True

tactic: intro ⟨h₁, h₂⟩
state_before: case mk.inl
ctx : Context
eq : Bool
lhs rhs : Poly
he : eq = true
⊢ Poly.isZero lhs = true ∧ Poly.isZero rhs = true → (Poly.denote ctx lhs = Poly.denote ctx rhs) = True

tactic: simp [Poly.of_isZero, h₁, h₂]
state_before: case mk.inl
ctx : Context
eq : Bool
lhs rhs : Poly
he : eq = true
h₁ : Poly.isZero lhs = true
h₂ : Poly.isZero rhs = true
⊢ (Poly.denote ctx lhs = Poly.denote ctx rhs) = True

tactic: intro h
state_before: case mk.inr
ctx : Context
eq : Bool
lhs rhs : Poly
he : ¬eq = true
⊢ Poly.isZero lhs = true → (Poly.denote ctx lhs ≤ Poly.denote ctx rhs) = True

tactic: simp [Poly.of_isZero, h]
state_before: case mk.inr
ctx : Context
eq : Bool
lhs rhs : Poly
he : ¬eq = true
h : Poly.isZero lhs = true
⊢ (Poly.denote ctx lhs ≤ Poly.denote ctx rhs) = True
Theorem: HasCompactSupport.smul_left
File: Mathlib/Topology/Support.lean

tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type ?u.20432
α : Type u_1
α' : Type ?u.20438
β : Type ?u.20441
γ : Type ?u.20444
δ : Type ?u.20447
M : Type u_2
E : Type ?u.20453
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : MonoidWithZero R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
f : α → R
f' : α → M
x : α
hf : HasCompactSupport f'
⊢ HasCompactSupport (f • f')

tactic: exact hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
state_before: X : Type ?u.20432
α : Type u_1
α' : Type ?u.20438
β : Type ?u.20441
γ : Type ?u.20444
δ : Type ?u.20447
M : Type u_2
E : Type ?u.20453
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : MonoidWithZero R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
f : α → R
f' : α → M
x : α
hf : f' =ᶠ[coclosedCompact α] 0
⊢ f • f' =ᶠ[coclosedCompact α] 0

tactic: simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
state_before: X : Type ?u.20432
α : Type u_1
α' : Type ?u.20438
β : Type ?u.20441
γ : Type ?u.20444
δ : Type ?u.20447
M : Type u_2
E : Type ?u.20453
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : MonoidWithZero R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
f : α → R
f' : α → M
x✝ : α
hf : f' =ᶠ[coclosedCompact α] 0
x : α
hx : f' x = OfNat.ofNat 0 x
⊢ (f • f') x = OfNat.ofNat 0 x
Theorem: hasFDerivAt_tsum
File: Mathlib/Analysis/Calculus/Series.lean

tactic: let : NormedSpace ℝ E
state_before: α : Type u_1
β : Type ?u.43853
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
⊢ HasFDerivAt (fun y => ∑' (n : α), f n y) (∑' (n : α), f' n x) x

tactic: exact NormedSpace.restrictScalars ℝ 𝕜 _
state_before: case this
α : Type u_1
β : Type ?u.43853
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
⊢ NormedSpace ℝ E

α : Type u_1
β : Type ?u.43853
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
this : NormedSpace ℝ E := ?this
⊢ HasFDerivAt (fun y => ∑' (n : α), f n y) (∑' (n : α), f' n x) x

tactic: exact hasFDerivAt_tsum_of_isPreconnected hu isOpen_univ isPreconnected_univ
  (fun n x _ => hf n x) (fun n x _ => hf' n x) (mem_univ _) hf0 (mem_univ _)
state_before: α : Type u_1
β : Type ?u.43853
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
this : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
⊢ HasFDerivAt (fun y => ∑' (n : α), f n y) (∑' (n : α), f' n x) x
Theorem: PosNum.le_iff_cmp
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cmp_swap]
state_before: m n : PosNum
⊢ cmp n m = Ordering.lt ↔ cmp m n = Ordering.gt

tactic: cases cmp m n <;> exact by decide
state_before: m n : PosNum
⊢ Ordering.swap (cmp m n) = Ordering.lt ↔ cmp m n = Ordering.gt

tactic: decide
state_before: m n : PosNum
⊢ Ordering.swap Ordering.gt = Ordering.lt ↔ Ordering.gt = Ordering.gt
Theorem: mem_zpowers_iff_mem_range_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← mem_powers_iff_mem_zpowers, mem_powers_iff_mem_range_orderOf]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝³ : Group G
inst✝² : AddGroup A
inst✝¹ : Finite G
inst✝ : DecidableEq G
⊢ y ∈ zpowers x ↔ y ∈ Finset.image ((fun x x_1 => x ^ x_1) x) (Finset.range (orderOf x))
Theorem: CategoryTheory.Limits.prod.diag_map_fst_snd
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ X Y : C
inst✝¹ : HasBinaryProduct X Y
inst✝ : HasBinaryProduct (X ⨯ Y) (X ⨯ Y)
⊢ diag (X ⨯ Y) ≫ map fst snd = 𝟙 (X ⨯ Y)
Theorem: SimpleGraph.Walk.map_snd_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa using congr_arg List.tail (cons_map_snd_darts p)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ List.map (fun x => x.snd) (darts p) = List.tail (support p)
Theorem: Matrix.SpecialLinearGroup.SL2_inv_expl_det
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: rw [Matrix.det_fin_two, mul_comm]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.737904
inst✝ : CommRing S
A : SL(2, R)
⊢ det ![![↑A 1 1, -↑A 0 1], ![-↑A 1 0, ↑A 0 0]] = 1

tactic: simp only [cons_val_zero, cons_val_one, head_cons, mul_neg, neg_mul, neg_neg]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.737904
inst✝ : CommRing S
A : SL(2, R)
⊢ vecCons ![↑A 1 1, -↑A 0 1] ![![-↑A 1 0, ↑A 0 0]] 1 1 * vecCons ![↑A 1 1, -↑A 0 1] ![![-↑A 1 0, ↑A 0 0]] 0 0 -
      vecCons ![↑A 1 1, -↑A 0 1] ![![-↑A 1 0, ↑A 0 0]] 0 1 * vecCons ![↑A 1 1, -↑A 0 1] ![![-↑A 1 0, ↑A 0 0]] 1 0 =
    1

tactic: have := A.2
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.737904
inst✝ : CommRing S
A : SL(2, R)
⊢ ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1

tactic: rw [Matrix.det_fin_two] at this
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.737904
inst✝ : CommRing S
A : SL(2, R)
this : det ↑A = 1
⊢ ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1

tactic: convert this
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type ?u.737904
inst✝ : CommRing S
A : SL(2, R)
this : ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1
⊢ ↑A 0 0 * ↑A 1 1 - ↑A 0 1 * ↑A 1 0 = 1