tasksource/leandojo huggingface dataset:
Theorem: Polynomial.Monic.degree_map
File: Mathlib/Data/Polynomial/Monic.lean

tactic: by_cases hP : P = 0
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
⊢ degree (Polynomial.map f P) = degree P

tactic: simp [hP]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : P = 0
⊢ degree (Polynomial.map f P) = degree P

tactic: refine' le_antisymm (degree_map_le _ _) _
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : ¬P = 0
⊢ degree (Polynomial.map f P) = degree P

tactic: rw [degree_eq_natDegree hP]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : ¬P = 0
⊢ degree P ≤ degree (Polynomial.map f P)

tactic: refine' le_degree_of_ne_zero _
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : ¬P = 0
⊢ ↑(natDegree P) ≤ degree (Polynomial.map f P)

tactic: rw [coeff_map, Monic.coeff_natDegree hmo, RingHom.map_one]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : ¬P = 0
⊢ coeff (Polynomial.map f P) (natDegree P) ≠ 0

tactic: exact one_ne_zero
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Nontrivial S
P : R[X]
hmo : Monic P
f : R →+* S
hP : ¬P = 0
⊢ 1 ≠ 0
Theorem: AdjoinRoot.aeval_eq
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [aeval_C]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
x : R
⊢ ↑(aeval (root f)) (↑C x) = ↑(mk f) (↑C x)

tactic: rfl
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
x : R
⊢ ↑(algebraMap R (AdjoinRoot f)) x = ↑(mk f) (↑C x)

tactic: rw [AlgHom.map_add, RingHom.map_add, ihp, ihq]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p✝ p q : R[X]
ihp : ↑(aeval (root f)) p = ↑(mk f) p
ihq : ↑(aeval (root f)) q = ↑(mk f) q
⊢ ↑(aeval (root f)) (p + q) = ↑(mk f) (p + q)

tactic: rw [AlgHom.map_mul, aeval_C, AlgHom.map_pow, aeval_X, RingHom.map_mul, mk_C, RingHom.map_pow,
  mk_X]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
n : ℕ
x : R
x✝ : ↑(aeval (root f)) (↑C x * X ^ n) = ↑(mk f) (↑C x * X ^ n)
⊢ ↑(aeval (root f)) (↑C x * X ^ (n + 1)) = ↑(mk f) (↑C x * X ^ (n + 1))

tactic: rfl
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
n : ℕ
x : R
x✝ : ↑(aeval (root f)) (↑C x * X ^ n) = ↑(mk f) (↑C x * X ^ n)
⊢ ↑(algebraMap R (AdjoinRoot f)) x * root f ^ (n + 1) = ↑(of f) x * root f ^ (n + 1)
Theorem: CompleteLattice.IsCompactElement.exists_finset_of_le_iSup
File: Mathlib/Order/CompactlyGenerated.lean

tactic: let g : Finset ι → α := fun s => ⨆ i ∈ s, f i
state_before: ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
⊢ ∃ s, k ≤ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: have h2 : k ≤ sSup (Set.range g) :=
  h.trans
    (iSup_le fun i =>
      le_sSup_of_le ⟨{i}, rfl⟩
        (le_iSup_of_le i (le_iSup_of_le (Finset.mem_singleton_self i) le_rfl)))
state_before: ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
g : Finset ι → α := fun s => ⨆ (i : ι) (_ : i ∈ s), f i
h1 : DirectedOn (fun x x_1 => x ≤ x_1) (Set.range g)
⊢ ∃ s, k ≤ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: obtain ⟨-, ⟨s, rfl⟩, hs⟩ :=
  (isCompactElement_iff_le_of_directed_sSup_le α k).mp hk (Set.range g) (Set.range_nonempty g)
    h1 h2
state_before: ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
g : Finset ι → α := fun s => ⨆ (i : ι) (_ : i ∈ s), f i
h1 : DirectedOn (fun x x_1 => x ≤ x_1) (Set.range g)
h2 : k ≤ sSup (Set.range g)
⊢ ∃ s, k ≤ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: exact ⟨s, hs⟩
state_before: case intro.intro.intro
ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
g : Finset ι → α := fun s => ⨆ (i : ι) (_ : i ∈ s), f i
h1 : DirectedOn (fun x x_1 => x ≤ x_1) (Set.range g)
h2 : k ≤ sSup (Set.range g)
s : Finset ι
hs : k ≤ g s
⊢ ∃ s, k ≤ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: rintro - ⟨s, rfl⟩ - ⟨t, rfl⟩
state_before: ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
g : Finset ι → α := fun s => ⨆ (i : ι) (_ : i ∈ s), f i
⊢ DirectedOn (fun x x_1 => x ≤ x_1) (Set.range g)

tactic: exact
  ⟨g (s ∪ t), ⟨s ∪ t, rfl⟩, iSup_le_iSup_of_subset (Finset.subset_union_left s t),
    iSup_le_iSup_of_subset (Finset.subset_union_right s t)⟩
state_before: case intro.intro
ι✝ : Sort ?u.10018
α : Type u_1
inst✝ : CompleteLattice α
f✝ : ι✝ → α
k : α
hk : IsCompactElement k
ι : Type u_2
f : ι → α
h : k ≤ ⨆ (i : ι), f i
g : Finset ι → α := fun s => ⨆ (i : ι) (_ : i ∈ s), f i
s t : Finset ι
⊢ ∃ z, z ∈ Set.range g ∧ (fun x x_1 => x ≤ x_1) (g s) z ∧ (fun x x_1 => x ≤ x_1) (g t) z
Theorem: SeminormFamily.basisSets_smul
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rcases p.basisSets_iff.mp hU with ⟨s, r, hr, hU⟩
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.63334
𝕝 : Type ?u.63337
𝕝₂ : Type ?u.63340
E : Type u_1
F : Type ?u.63346
G : Type ?u.63349
ι : Type u_3
ι' : Type ?u.63355
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
U : Set E
hU : U ∈ basisSets p
⊢ ∃ V, V ∈ 𝓝 0 ∧ ∃ W, W ∈ AddGroupFilterBasis.toFilterBasis.sets ∧ V • W ⊆ U

tactic: refine' ⟨Metric.ball 0 r.sqrt, Metric.ball_mem_nhds 0 (Real.sqrt_pos.mpr hr), _⟩
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.63334
𝕝 : Type ?u.63337
𝕝₂ : Type ?u.63340
E : Type u_1
F : Type ?u.63346
G : Type ?u.63349
ι : Type u_3
ι' : Type ?u.63355
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
U : Set E
hU✝ : U ∈ basisSets p
s : Finset ι
r : ℝ
hr : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ ∃ V, V ∈ 𝓝 0 ∧ ∃ W, W ∈ AddGroupFilterBasis.toFilterBasis.sets ∧ V • W ⊆ U

tactic: refine' ⟨(s.sup p).ball 0 r.sqrt, p.basisSets_mem s (Real.sqrt_pos.mpr hr), _⟩
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.63334
𝕝 : Type ?u.63337
𝕝₂ : Type ?u.63340
E : Type u_1
F : Type ?u.63346
G : Type ?u.63349
ι : Type u_3
ι' : Type ?u.63355
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
U : Set E
hU✝ : U ∈ basisSets p
s : Finset ι
r : ℝ
hr : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ ∃ W, W ∈ AddGroupFilterBasis.toFilterBasis.sets ∧ Metric.ball 0 (Real.sqrt r) • W ⊆ U

tactic: refine' Set.Subset.trans (ball_smul_ball (s.sup p) r.sqrt r.sqrt) _
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.63334
𝕝 : Type ?u.63337
𝕝₂ : Type ?u.63340
E : Type u_1
F : Type ?u.63346
G : Type ?u.63349
ι : Type u_3
ι' : Type ?u.63355
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
U : Set E
hU✝ : U ∈ basisSets p
s : Finset ι
r : ℝ
hr : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ Metric.ball 0 (Real.sqrt r) • ball (Finset.sup s p) 0 (Real.sqrt r) ⊆ U

tactic: rw [hU, Real.mul_self_sqrt (le_of_lt hr)]
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.63334
𝕝 : Type ?u.63337
𝕝₂ : Type ?u.63340
E : Type u_1
F : Type ?u.63346
G : Type ?u.63349
ι : Type u_3
ι' : Type ?u.63355
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
U : Set E
hU✝ : U ∈ basisSets p
s : Finset ι
r : ℝ
hr : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ ball (Finset.sup s p) 0 (Real.sqrt r * Real.sqrt r) ⊆ U
Theorem: Ordinal.nat_cast_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Cardinal.ord_nat, ← Cardinal.ord_nat, Cardinal.ord_le_ord, Cardinal.natCast_le]
state_before: m n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ n
Theorem: Nat.add_right_comm
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_assoc, Nat.add_comm m k, ← Nat.add_assoc]
state_before: n m k : Nat
⊢ n + m + k = n + k + m
Theorem: Multiset.singleton_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.11036
δ : Type ?u.11039
a : α
s t : Multiset α
f g : α → Multiset β
⊢ bind {a} f = f a
Theorem: IsAlgClosed.splits_codomain
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

tactic: convert IsAlgClosed.splits (p.map f)
state_before: k✝ : Type u
inst✝³ : Field k✝
k : Type u_1
K : Type u_2
inst✝² : Field k
inst✝¹ : IsAlgClosed k
inst✝ : Field K
f : K →+* k
p : K[X]
⊢ Splits f p

tactic: simp [splits_map_iff]
state_before: case a
k✝ : Type u
inst✝³ : Field k✝
k : Type u_1
K : Type u_2
inst✝² : Field k
inst✝¹ : IsAlgClosed k
inst✝ : Field K
f : K →+* k
p : K[X]
⊢ Splits f p ↔ Splits (RingHom.id k) (map f p)
Theorem: Filter.mem_iff_ultrafilter
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: refine' ⟨fun hf g hg => hg hf, fun H => by_contra fun hf => _⟩
state_before: α : Type u
β : Type v
γ : Type ?u.37751
f : Filter α
s : Set α
a : α
⊢ s ∈ f ↔ ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g

tactic: set g : Filter (sᶜ : Set α) := comap (↑) f
state_before: α : Type u
β : Type v
γ : Type ?u.37751
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : ¬s ∈ f
⊢ False

tactic: haveI : NeBot g := comap_neBot_iff_compl_range.2 (by simpa [compl_setOf] )
state_before: α : Type u
β : Type v
γ : Type ?u.37751
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : ¬s ∈ f
g : Filter ↑(sᶜ) := comap Subtype.val f
⊢ False

tactic: simpa using H ((of g).map (↑)) (map_le_iff_le_comap.mpr (of_le g))
state_before: α : Type u
β : Type v
γ : Type ?u.37751
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : ¬s ∈ f
g : Filter ↑(sᶜ) := comap Subtype.val f
this : NeBot g
⊢ False

tactic: simpa [compl_setOf]
state_before: α : Type u
β : Type v
γ : Type ?u.37751
f : Filter α
s : Set α
a : α
H : ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g
hf : ¬s ∈ f
g : Filter ↑(sᶜ) := comap Subtype.val f
⊢ ¬range Subtype.valᶜ ∈ f
Theorem: Mathlib.Tactic.Ring.mul_pow
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea₁ b c₁ : ℕ
a₂ c₂ xa₁ : R
x✝¹ : ea₁ * b = c₁
x✝ : a₂ ^ b = c₂
⊢ (xa₁ ^ ea₁ * a₂) ^ b = xa₁ ^ c₁ * c₂

tactic: simp [_root_.mul_pow, pow_mul]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea₁ b : ℕ
a₂ xa₁ : R
⊢ (xa₁ ^ ea₁ * a₂) ^ b = xa₁ ^ (ea₁ * b) * a₂ ^ b
Theorem: Subalgebra.toSubsemiring_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [← mem_toSubsemiring, ← mem_toSubsemiring, h]
state_before: R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
S T : Subalgebra R A
h : S.toSubsemiring = T.toSubsemiring
x : A
⊢ x ∈ S ↔ x ∈ T
Theorem: Polynomial.degree_map_eq_of_leadingCoeff_ne_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: have hp0 : p ≠ 0 :=
  leadingCoeff_ne_zero.mp fun hp0 => hf (_root_.trans (congr_arg _ hp0) f.map_zero)
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
⊢ degree p ≤ degree (map f p)

tactic: rw [degree_eq_natDegree hp0]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
hp0 : p ≠ 0
⊢ degree p ≤ degree (map f p)

tactic: refine' le_degree_of_ne_zero _
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
hp0 : p ≠ 0
⊢ ↑(natDegree p) ≤ degree (map f p)

tactic: rw [coeff_map]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
hp0 : p ≠ 0
⊢ coeff (map f p) (natDegree p) ≠ 0

tactic: exact hf
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
hp0 : p ≠ 0
⊢ ↑f (coeff p (natDegree p)) ≠ 0
Theorem: Turing.reaches₁_fwd
File: Mathlib/Computability/TuringMachine.lean

tactic: rcases TransGen.head'_iff.1 h₁ with ⟨b', hab, hbc⟩
state_before: σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ : b ∈ f a
⊢ Reaches f b c

tactic: cases Option.mem_unique hab h₂
state_before: case intro.intro
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ : b ∈ f a
b' : σ
hab : b' ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b' c
⊢ Reaches f b c

tactic: exact hbc
state_before: case intro.intro.refl
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ hab : b ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b c
⊢ Reaches f b c
Theorem: Int.natAbs_sub_le
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.natAbs_neg b]
state_before: a b : Int
⊢ natAbs (a - b) ≤ natAbs a + natAbs b

tactic: apply natAbs_add_le
state_before: a b : Int
⊢ natAbs (a - b) ≤ natAbs a + natAbs (-b)
Theorem: Asymptotics.IsTheta.div
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simpa only [div_eq_mul_inv] using h₁.mul h₂.inv
state_before: α : Type u_1
β : Type ?u.44608
E : Type ?u.44611
F : Type ?u.44614
G : Type ?u.44617
E' : Type ?u.44620
F' : Type ?u.44623
G' : Type ?u.44626
E'' : Type ?u.44629
F'' : Type ?u.44632
G'' : Type ?u.44635
R : Type ?u.44638
R' : Type ?u.44641
𝕜 : Type u_2
𝕜' : Type u_3
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''
l l' : Filter α
f₁ f₂ : α → 𝕜
g₁ g₂ : α → 𝕜'
h₁ : f₁ =Θ[l] g₁
h₂ : f₂ =Θ[l] g₂
⊢ (fun x => f₁ x / f₂ x) =Θ[l] fun x => g₁ x / g₂ x
Theorem: SimpleGraph.Walk.IsPath.nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ IsPath Walk.nil
Theorem: nhdsSet_univ
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [isOpen_univ.nhdsSet_eq, principal_univ]
state_before: α : Type u_1
β : Type ?u.12597
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
⊢ 𝓝ˢ univ = ⊤
Theorem: sup_sdiff_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type ?u.59418
α : Type u_1
β : Type ?u.59424
π : ι → Type ?u.59429
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ (a ⊔ b) \ (a ⊓ b) = a ∆ b
Theorem: Finset.filter_mem_eq_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, mem_inter]
state_before: α : Type u_1
β : Type ?u.372476
γ : Type ?u.372479
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
inst✝¹ : DecidableEq α
s t : Finset α
inst✝ : (i : α) → Decidable (i ∈ t)
i : α
⊢ i ∈ filter (fun i => i ∈ t) s ↔ i ∈ s ∩ t
Theorem: Sym2.mem_iff'
File: Mathlib/Data/Sym/Sym2.lean

tactic: rintro ⟨_, h⟩
state_before: α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b c : α
⊢ Sym2.Mem a (Quotient.mk (Rel.setoid α) (b, c)) → a = b ∨ a = c

tactic: rw [eq_iff] at h
state_before: case intro
α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b c w✝ : α
h : Quotient.mk (Rel.setoid α) (b, c) = Quotient.mk (Rel.setoid α) (a, w✝)
⊢ a = b ∨ a = c

tactic: aesop
state_before: case intro
α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b c w✝ : α
h : b = a ∧ c = w✝ ∨ b = w✝ ∧ c = a
⊢ a = b ∨ a = c

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b c : α
⊢ a = b ∨ a = c → Sym2.Mem a (Quotient.mk (Rel.setoid α) (b, c))

tactic: rw [eq_swap]
state_before: case inr
α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b : α
⊢ Sym2.Mem a (Quotient.mk (Rel.setoid α) (b, a))

tactic: exact ⟨_, rfl⟩
state_before: case inr
α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a b : α
⊢ Sym2.Mem a (Quotient.mk (Rel.setoid α) (a, b))

tactic: exact ⟨_, rfl⟩
state_before: case inl
α : Type u_1
β : Type ?u.17778
γ : Type ?u.17781
a c : α
⊢ Sym2.Mem a (Quotient.mk (Rel.setoid α) (a, c))
Theorem: lowerBounds_insert
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [insert_eq, lowerBounds_union, lowerBounds_singleton]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
a✝ b a : α
s : Set α
⊢ lowerBounds (insert a s) = Iic a ∩ lowerBounds s
Theorem: Finset.affineCombination_filter_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [affineCombination_apply, affineCombination_apply,
  s.weightedVSubOfPoint_filter_of_ne _ _ _ h]
state_before: k : Type u_2
V : Type u_4
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.369441
s₂ : Finset ι₂
w : ι → k
p : ι → P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
⊢ ↑(affineCombination k (filter pred s) p) w = ↑(affineCombination k s p) w
Theorem: SimpleGraph.Walk.dropUntil_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w v' w' : V
p : Walk G v w
hv : v = v'
hw : w = w'
h : u ∈ support (Walk.copy p hv hw)
⊢ u ∈ support p

tactic: exact h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v' w' : V
p : Walk G v' w'
h : u ∈ support (Walk.copy p (_ : v' = v') (_ : w' = w'))
⊢ u ∈ support p

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w v' w' : V
p : Walk G v w
hv : v = v'
hw : w = w'
h : u ∈ support (Walk.copy p hv hw)
⊢ dropUntil (Walk.copy p hv hw) u h = Walk.copy (dropUntil p u (_ : u ∈ support p)) (_ : u = u) hw

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v' w' : V
p : Walk G v' w'
h : u ∈ support (Walk.copy p (_ : v' = v') (_ : w' = w'))
⊢ dropUntil (Walk.copy p (_ : v' = v') (_ : w' = w')) u h =
    Walk.copy (dropUntil p u (_ : u ∈ support p)) (_ : u = u) (_ : w' = w')
Theorem: BumpCovering.exists_finset_toPouFun_eventuallyEq
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: rcases f.locallyFinite x with ⟨U, hU, hf⟩
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
⊢ ∃ t, toPouFun f i =ᶠ[𝓝 x] ↑(toFun s f i) * ↑(∏ j in Finset.filter (fun j => WellOrderingRel j i) t, (1 - toFun s f j))

tactic: use hf.toFinset
state_before: case intro.intro
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
⊢ ∃ t, toPouFun f i =ᶠ[𝓝 x] ↑(toFun s f i) * ↑(∏ j in Finset.filter (fun j => WellOrderingRel j i) t, (1 - toFun s f j))

tactic: filter_upwards [hU]with y hyU
state_before: case intro.intro
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
⊢ toPouFun f i =ᶠ[𝓝 x]
    ↑(toFun s f i) * ↑(∏ j in Finset.filter (fun j => WellOrderingRel j i) (Finite.toFinset hf), (1 - toFun s f j))

tactic: simp only [ContinuousMap.coe_prod, Pi.mul_apply, Finset.prod_apply]
state_before: case h
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
y : X
hyU : y ∈ U
⊢ toPouFun f i y =
    (↑(toFun s f i) * ↑(∏ j in Finset.filter (fun j => WellOrderingRel j i) (Finite.toFinset hf), (1 - toFun s f j))) y

tactic: apply toPouFun_eq_mul_prod
state_before: case h
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
y : X
hyU : y ∈ U
⊢ toPouFun f i y =
    ↑(toFun s f i) y * ∏ c in Finset.filter (fun j => WellOrderingRel j i) (Finite.toFinset hf), ↑(1 - toFun s f c) y

tactic: intro j _ hj
state_before: case h.ht
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
y : X
hyU : y ∈ U
⊢ ∀ (j : ι), WellOrderingRel j i → ↑(toFun s f j) y ≠ 0 → j ∈ Finite.toFinset hf

tactic: exact hf.mem_toFinset.2 ⟨y, ⟨hj, hyU⟩⟩
state_before: case h.ht
ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
U : Set X
hU : U ∈ 𝓝 x
hf : Set.Finite {i | Set.Nonempty ((fun i => support ↑(toFun s f i)) i ∩ U)}
y : X
hyU : y ∈ U
j : ι
a✝ : WellOrderingRel j i
hj : ↑(toFun s f j) y ≠ 0
⊢ j ∈ Finite.toFinset hf
Theorem: div_mul_le_div_mul_of_div_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_mul_eq_div_mul_one_div, div_mul_eq_div_mul_one_div]
state_before: ι : Type ?u.107585
α : Type u_1
β : Type ?u.107591
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / (b * e) ≤ c / (d * e)

tactic: exact mul_le_mul_of_nonneg_right h (one_div_nonneg.2 he)
state_before: ι : Type ?u.107585
α : Type u_1
β : Type ?u.107591
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / b * (1 / e) ≤ c / d * (1 / e)
Theorem: Ideal.pow_mono
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: induction' n with _ hn
state_before: R : Type u
ι : Type ?u.295460
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n : ℕ
⊢ I ^ n ≤ J ^ n

tactic: rw [pow_zero, pow_zero]
state_before: case zero
R : Type u
ι : Type ?u.295460
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
⊢ I ^ Nat.zero ≤ J ^ Nat.zero

tactic: rw [pow_succ, pow_succ]
state_before: case succ
R : Type u
ι : Type ?u.295460
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I ^ Nat.succ n✝ ≤ J ^ Nat.succ n✝

tactic: exact Ideal.mul_mono e hn
state_before: case succ
R : Type u
ι : Type ?u.295460
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I * I ^ n✝ ≤ J * J ^ n✝
Theorem: Int.mul_nonpos_of_nonpos_of_nonneg
File: Std/Data/Int/Lemmas.lean

tactic: have h : a * b ≤ 0 * b := Int.mul_le_mul_of_nonneg_right ha hb
state_before: a b : Int
ha : a ≤ 0
hb : 0 ≤ b
⊢ a * b ≤ 0

tactic: rwa [Int.zero_mul] at h
state_before: a b : Int
ha : a ≤ 0
hb : 0 ≤ b
h : a * b ≤ 0 * b
⊢ a * b ≤ 0