tasksource/leandojo huggingface dataset:
Theorem: Polynomial.isCoprime_of_is_root_of_eval_derivative_ne_zero
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: refine Or.resolve_left
    (EuclideanDomain.dvd_or_coprime (X - C a) (f /ₘ (X - C a))
      (irreducible_of_degree_eq_one (Polynomial.degree_X_sub_C a))) ?_
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf' : eval a (↑derivative f) ≠ 0
⊢ IsCoprime (X - ↑C a) (f /ₘ (X - ↑C a))

tactic: contrapose! hf' with h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
hf' : eval a (↑derivative f) ≠ 0
⊢ ¬X - ↑C a ∣ f /ₘ (X - ↑C a)

tactic: have : X - C a ∣ derivative f := X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic f h
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
h : X - ↑C a ∣ f /ₘ (X - ↑C a)
⊢ eval a (↑derivative f) = 0

tactic: rw [← dvd_iff_modByMonic_eq_zero (monic_X_sub_C _), modByMonic_X_sub_C_eq_C_eval] at this
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
h : X - ↑C a ∣ f /ₘ (X - ↑C a)
this : X - ↑C a ∣ ↑derivative f
⊢ eval a (↑derivative f) = 0

tactic: rwa [← C_inj, C_0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
h : X - ↑C a ∣ f /ₘ (X - ↑C a)
this : ↑C (eval a (↑derivative f)) = 0
⊢ eval a (↑derivative f) = 0
Theorem: Rat.add_left_neg
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [h, mkRat_add_mkRat]
state_before: a b c : ℚ
n : ℤ
d : ℕ
h : d ≠ 0
⊢ -(n /. ↑d) + n /. ↑d = 0
Theorem: intervalIntegral.norm_integral_le_of_norm_le
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [norm_intervalIntegral_eq, abs_intervalIntegral_eq,
  abs_eq_self.mpr (integral_nonneg_of_ae <| h.mono fun _t ht => (norm_nonneg _).trans ht),
  norm_integral_le_of_norm_le hbound.def h]
state_before: ι : Type ?u.12172012
𝕜 : Type ?u.12172015
E : Type u_1
F : Type ?u.12172021
A : Type ?u.12172024
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g✝ : ℝ → E
μ : MeasureTheory.Measure ℝ
g : ℝ → ℝ
h : ∀ᵐ (t : ℝ) ∂Measure.restrict μ (Ι a b), ‖f t‖ ≤ g t
hbound : IntervalIntegrable g μ a b
⊢ ‖∫ (t : ℝ) in a..b, f t ∂μ‖ ≤ abs (∫ (t : ℝ) in a..b, g t ∂μ)
Theorem: Nat.mod_one
File: src/lean/Init/Data/Nat/Div.lean

tactic: have h : x % 1 < 1 := mod_lt x (by decide)
state_before: x : Nat
⊢ x % 1 = 0

tactic: have : (y : Nat) → y < 1 → y = 0 := by
  intro y
  cases y with
  | zero   => intro _; rfl
  | succ y => intro h; apply absurd (Nat.lt_of_succ_lt_succ h) (Nat.not_lt_zero y)
state_before: x : Nat
h : x % 1 < 1
⊢ x % 1 = 0

tactic: exact this _ h
state_before: x : Nat
h : x % 1 < 1
this : ∀ (y : Nat), y < 1 → y = 0
⊢ x % 1 = 0

tactic: decide
state_before: x : Nat
⊢ 1 > 0

tactic: intro y
state_before: x : Nat
h : x % 1 < 1
⊢ ∀ (y : Nat), y < 1 → y = 0

tactic: cases y with
| zero   => intro _; rfl
| succ y => intro h; apply absurd (Nat.lt_of_succ_lt_succ h) (Nat.not_lt_zero y)
state_before: x : Nat
h : x % 1 < 1
y : Nat
⊢ y < 1 → y = 0

tactic: intro _
state_before: case zero
x : Nat
h : x % 1 < 1
⊢ zero < 1 → zero = 0

tactic: rfl
state_before: case zero
x : Nat
h : x % 1 < 1
a✝ : zero < 1
⊢ zero = 0

tactic: intro h
state_before: case succ
x : Nat
h : x % 1 < 1
y : Nat
⊢ succ y < 1 → succ y = 0

tactic: apply absurd (Nat.lt_of_succ_lt_succ h) (Nat.not_lt_zero y)
state_before: case succ
x : Nat
h✝ : x % 1 < 1
y : Nat
h : succ y < 1
⊢ succ y = 0
Theorem: Valued.continuous_valuation
File: Mathlib/Topology/Algebra/ValuedField.lean

tactic: rw [continuous_iff_continuousAt]
state_before: K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ Continuous ↑v

tactic: intro x
state_before: K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ∀ (x : K), ContinuousAt (↑v) x

tactic: rcases eq_or_ne x 0 with (rfl | h)
state_before: K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
⊢ ContinuousAt (↑v) x

tactic: rw [ContinuousAt, map_zero, WithZeroTopology.tendsto_zero]
state_before: case inl
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ContinuousAt (↑v) 0

tactic: intro γ hγ
state_before: case inl
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ∀ (γ₀ : Γ₀), γ₀ ≠ 0 → ∀ᶠ (x : K) in 𝓝 0, ↑v x < γ₀

tactic: rw [Filter.Eventually, Valued.mem_nhds_zero]
state_before: case inl
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ ∀ᶠ (x : K) in 𝓝 0, ↑v x < γ

tactic: use Units.mk0 γ hγ
state_before: case inl
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ ∃ γ_1, {x | ↑v x < ↑γ_1} ⊆ {x | ↑v x < γ}

tactic: rfl
state_before: case inl
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ {x | ↑v x < ↑(Units.mk0 γ hγ)} ⊆ {x | ↑v x < γ}

tactic: have v_ne : (v x : Γ₀) ≠ 0 := (Valuation.ne_zero_iff _).mpr h
state_before: case inr
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
⊢ ContinuousAt (↑v) x

tactic: rw [ContinuousAt, WithZeroTopology.tendsto_of_ne_zero v_ne]
state_before: case inr
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
v_ne : ↑v x ≠ 0
⊢ ContinuousAt (↑v) x

tactic: apply Valued.loc_const v_ne
state_before: case inr
K : Type u_2
inst✝² : DivisionRing K
Γ₀ : Type u_1
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
v_ne : ↑v x ≠ 0
⊢ ∀ᶠ (x_1 : K) in 𝓝 x, ↑v x_1 = ↑v x
Theorem: CharTwo.multiset_sum_mul_self
File: Mathlib/Algebra/CharP/Two.lean

tactic: simp_rw [← pow_two, multiset_sum_sq]
state_before: R : Type u_1
ι : Type ?u.17742
inst✝¹ : CommSemiring R
inst✝ : CharP R 2
l : Multiset R
⊢ Multiset.sum l * Multiset.sum l = Multiset.sum (Multiset.map (fun x => x * x) l)
Theorem: Metric.isCompact_of_isClosed_bounded
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, -⟩)
state_before: α : Type u
β : Type v
X : Type ?u.526468
ι : Type ?u.526471
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : Bounded s
⊢ IsCompact s

tactic: exact isCompact_empty
state_before: case inl
α : Type u
β : Type v
X : Type ?u.526468
ι : Type ?u.526471
inst✝¹ : PseudoMetricSpace α
x : α
t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed ∅
hb : Bounded ∅
⊢ IsCompact ∅

tactic: rcases hb.subset_ball x with ⟨r, hr⟩
state_before: case inr.intro
α : Type u
β : Type v
X : Type ?u.526468
ι : Type ?u.526471
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : Bounded s
x : α
⊢ IsCompact s

tactic: exact isCompact_of_isClosed_subset (isCompact_closedBall x r) hc hr
state_before: case inr.intro.intro
α : Type u
β : Type v
X : Type ?u.526468
ι : Type ?u.526471
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r✝ : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : Bounded s
x : α
r : ℝ
hr : s ⊆ closedBall x r
⊢ IsCompact s
Theorem: CategoryTheory.Limits.prod.map_swap
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ A B X Y : C
f : A ⟶ B
g : X ⟶ Y
inst✝ : HasLimitsOfShape (Discrete WalkingPair) C
⊢ map (𝟙 X) f ≫ map g (𝟙 B) = map g (𝟙 A) ≫ map (𝟙 Y) f
Theorem: Equiv.hasSum_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
δ : Type ?u.56247
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
e : γ ≃ β
⊢ ∀ (x : β), ¬x ∈ Set.range ↑e → f x = 0
Theorem: Int.gcd_self
File: Mathlib/Data/Int/GCD.lean

tactic: simp [gcd]
state_before: i : ℤ
⊢ gcd i i = natAbs i
Theorem: Uniform.continuousWithinAt_iff'_right
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [ContinuousWithinAt, tendsto_nhds_right]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.198607
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
s : Set β
⊢ ContinuousWithinAt f s b ↔ Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α)
Theorem: Nat.properDivisors_zero
File: Mathlib/NumberTheory/Divisors.lean

tactic: ext
state_before: n : ℕ
⊢ properDivisors 0 = ∅

tactic: simp
state_before: case a
n a✝ : ℕ
⊢ a✝ ∈ properDivisors 0 ↔ a✝ ∈ ∅
Theorem: Filter.tendsto_mul_const_atTop_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atTop_of_pos hr
state_before: ι : Type ?u.216245
ι' : Type ?u.216248
α : Type u_1
β : Type u_2
γ : Type ?u.216257
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
hr : 0 < r
⊢ Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atTop
Theorem: IsCompact.closedBall_div
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, hs.closedBall_mul hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ closedBall x δ * s = x • cthickening δ s
Theorem: IsCompact.bddBelow
File: Mathlib/Topology/Order/Basic.lean

tactic: cases' botOrderOrNoBotOrder α with h h
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
⊢ BddBelow s

tactic: exact OrderBot.bddBelow s
state_before: case inl
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : OrderBot α
⊢ BddBelow s

case inr
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
⊢ BddBelow s

tactic: have : s ⊆ ⋃ a : α, Ioi a := (@iUnion_Ioi α _ (NoBotOrder.to_noMinOrder α)).symm ▸ subset_univ s
state_before: case inr
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
⊢ BddBelow s

tactic: rcases hs.elim_finite_subcover _ (fun _ => isOpen_Ioi) this with ⟨t, ht⟩
state_before: case inr
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
this : s ⊆ ⋃ (a : α), Ioi a
⊢ BddBelow s

tactic: refine t.bddBelow.imp fun C hC y hy => ?_
state_before: case inr.intro
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
this : s ⊆ ⋃ (a : α), Ioi a
t : Finset α
ht : s ⊆ ⋃ (i : α) (_ : i ∈ t), Ioi i
⊢ BddBelow s

tactic: rcases mem_iUnion₂.1 (ht hy) with ⟨a, ha, hay⟩
state_before: case inr.intro
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
this : s ⊆ ⋃ (a : α), Ioi a
t : Finset α
ht : s ⊆ ⋃ (i : α) (_ : i ∈ t), Ioi i
C : α
hC : C ∈ lowerBounds ↑t
y : α
hy : y ∈ s
⊢ C ≤ y

tactic: exact (hC ha).trans (le_of_lt hay)
state_before: case inr.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
f g : β → α
inst✝¹ : Nonempty α
inst✝ : TopologicalSpace β
s : Set α
hs : IsCompact s
h : NoBotOrder α
this : s ⊆ ⋃ (a : α), Ioi a
t : Finset α
ht : s ⊆ ⋃ (i : α) (_ : i ∈ t), Ioi i
C : α
hC : C ∈ lowerBounds ↑t
y : α
hy : y ∈ s
a : α
ha : a ∈ t
hay : y ∈ Ioi a
⊢ C ≤ y
Theorem: Univ.isSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

tactic: constructor <;> simp
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type ?u.23073
inst✝ : AddMonoid A
t : Set A
⊢ IsSubmonoid Set.univ
Theorem: RatFunc.num_denom_neg
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [num_mul_eq_mul_denom_iff (denom_ne_zero x), _root_.map_neg, neg_div, num_div_denom]
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
⊢ num (-x) * denom x = -num x * denom (-x)
Theorem: TensorProduct.directSumLeft_tmul_lof
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: dsimp only [directSumLeft, LinearEquiv.ofLinear_apply, lift.tmul]
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
i : ι₁
x : M₁ i
y : M₂'
⊢ ↑(directSumLeft R M₁ M₂') (↑(lof R ι₁ M₁ i) x ⊗ₜ[R] y) = ↑(lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i) (x ⊗ₜ[R] y)

tactic: rw [DirectSum.toModule_lof R i]
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
i : ι₁
x : M₁ i
y : M₂'
⊢ ↑(↑(toModule R ι₁ (M₂' →ₗ[R] ⨁ (i : ι₁), M₁ i ⊗[R] M₂') fun i =>
              compr₂ (mk R (M₁ i) M₂') (lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i))
          (↑(lof R ι₁ M₁ i) x))
      y =
    ↑(lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i) (x ⊗ₜ[R] y)

tactic: rfl
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
i : ι₁
x : M₁ i
y : M₂'
⊢ ↑(↑(compr₂ (mk R (M₁ i) M₂') (lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i)) x) y =
    ↑(lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i) (x ⊗ₜ[R] y)
Theorem: CategoryTheory.Functor.comp_id
File: Mathlib/CategoryTheory/Functor/Basic.lean

tactic: cases F
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
⊢ F ⋙ 𝟭 D = F

tactic: rfl
state_before: case mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
toPrefunctor✝ : C ⥤q D
map_id✝ : ∀ (X : C), toPrefunctor✝.map (𝟙 X) = 𝟙 (toPrefunctor✝.obj X)
map_comp✝ : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), toPrefunctor✝.map (f ≫ g) = toPrefunctor✝.map f ≫ toPrefunctor✝.map g
⊢ mk toPrefunctor✝ ⋙ 𝟭 D = mk toPrefunctor✝
Theorem: Polynomial.coprime_of_root_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: apply Nat.coprime.symm
state_before: n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : IsRoot (cyclotomic n (ZMod p)) (↑(Nat.castRingHom (ZMod p)) a)
⊢ Nat.coprime a p

tactic: rw [hprime.1.coprime_iff_not_dvd]
state_before: case a
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : IsRoot (cyclotomic n (ZMod p)) (↑(Nat.castRingHom (ZMod p)) a)
⊢ Nat.coprime p a

tactic: intro h
state_before: case a
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : IsRoot (cyclotomic n (ZMod p)) (↑(Nat.castRingHom (ZMod p)) a)
⊢ ¬p ∣ a

tactic: replace h := (ZMod.nat_cast_zmod_eq_zero_iff_dvd a p).2 h
state_before: case a
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : IsRoot (cyclotomic n (ZMod p)) (↑(Nat.castRingHom (ZMod p)) a)
h : p ∣ a
⊢ False

tactic: rw [IsRoot.def, eq_natCast, h, ← coeff_zero_eq_eval_zero] at hroot
state_before: case a
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : IsRoot (cyclotomic n (ZMod p)) (↑(Nat.castRingHom (ZMod p)) a)
h : ↑a = 0
⊢ False

tactic: by_cases hone : n = 1
state_before: case a
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : coeff (cyclotomic n (ZMod p)) 0 = 0
h : ↑a = 0
⊢ False

tactic: rw [cyclotomic_coeff_zero (ZMod p) (Nat.succ_le_of_lt
  (lt_of_le_of_ne (Nat.succ_le_of_lt hpos) (Ne.symm hone)))] at hroot
state_before: case neg
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : coeff (cyclotomic n (ZMod p)) 0 = 0
h : ↑a = 0
hone : ¬n = 1
⊢ False

tactic: exact one_ne_zero hroot
state_before: case neg
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : 1 = 0
h : ↑a = 0
hone : ¬n = 1
⊢ False

tactic: simp only [hone, cyclotomic_one, zero_sub, coeff_one_zero, coeff_X_zero, neg_eq_zero,
  one_ne_zero, coeff_sub] at hroot
state_before: case pos
n : ℕ
hpos : 0 < n
p : ℕ
hprime : Fact (Nat.Prime p)
a : ℕ
hroot : coeff (cyclotomic n (ZMod p)) 0 = 0
h : ↑a = 0
hone : n = 1
⊢ False
Theorem: Sym.map_id'
File: Mathlib/Data/Sym/Basic.lean

tactic: ext
state_before: α✝ : Type ?u.35215
β : Type ?u.35218
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_1
n : ℕ
s : Sym α n
⊢ map (fun x => x) s = s

tactic: simp [Sym.map]
state_before: case h
α✝ : Type ?u.35215
β : Type ?u.35218
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_1
n : ℕ
s : Sym α n
⊢ ↑(map (fun x => x) s) = ↑s

tactic: rfl
state_before: case h
α✝ : Type ?u.35215
β : Type ?u.35218
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_1
n : ℕ
s : Sym α n
⊢ { val := ↑s, property := (_ : (fun s => ↑Multiset.card s = n) ↑s) } = s
Theorem: SimpleGraph.Walk.bypass_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 u' v' : V
p : Walk G u v
hu : u = u'
hv : v = v'
⊢ bypass (Walk.copy p hu hv) = Walk.copy (bypass p) hu hv

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' : V
p : Walk G u' v'
⊢ bypass (Walk.copy p (_ : u' = u') (_ : v' = v')) = Walk.copy (bypass p) (_ : u' = u') (_ : v' = v')
Theorem: thickenedIndicatorAux_one_of_mem_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: rw [← thickenedIndicatorAux_closure_eq, thickenedIndicatorAux_one δ (closure E) x_mem]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
x : α
x_mem : x ∈ closure E
⊢ thickenedIndicatorAux δ E x = 1
Theorem: Finset.zero_smul_finset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simpa using @Set.zero_smul_set α _ _ _ _ _ h
state_before: F : Type ?u.929758
α : Type u_2
β : Type u_1
γ : Type ?u.929767
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
inst✝ : DecidableEq β
s✝ : Finset α
t s : Finset β
h : Finset.Nonempty s
⊢ ↑(0 • s) = ↑0
Theorem: Doset.mk_eq_of_doset_eq
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: rw [eq]
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.39521
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : doset a ↑H ↑K = doset b ↑H ↑K
⊢ mk H K a = mk H K b

tactic: exact mem_doset.mp (h.symm ▸ mem_doset_self H K b)
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.39521
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : doset a ↑H ↑K = doset b ↑H ↑K
⊢ ∃ h, h ∈ H ∧ ∃ k, k ∈ K ∧ b = h * a * k
Theorem: Vector3.append_left
File: Mathlib/Data/Vector3.lean

tactic: simp [*, left]
state_before: α : Type u_1
m✝ n✝ m : ℕ
v : Vector3 α (succ m)
n : ℕ
w : Vector3 α n
a : α
_t : Vector3 α m
⊢ ((a :: _t) +-+ w) (left n fz) = (a :: _t) fz

tactic: simp [append_left, left]
state_before: α : Type u_1
m✝ n✝ m : ℕ
i : Fin2 m
v : Vector3 α (succ m)
n : ℕ
w : Vector3 α n
_a : α
t : Vector3 α m
⊢ ((_a :: t) +-+ w) (left n (fs i)) = (_a :: t) (fs i)
Theorem: Finpartition.atomise_empty
File: Mathlib/Order/Partition/Finpartition.lean

tactic: simp only [atomise, powerset_empty, image_singleton, not_mem_empty, IsEmpty.forall_iff,
  imp_true_iff, filter_True]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
hs : Finset.Nonempty s
⊢ (atomise s ∅).parts = {s}

tactic: exact erase_eq_of_not_mem (not_mem_singleton.2 hs.ne_empty.symm)
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
F : Finset (Finset α)
hs : Finset.Nonempty s
⊢ (ofErase {s} (_ : SupIndep {s} id) (_ : sup {s} id = s)).parts = {s}
Theorem: Real.log_lt_sub_one_of_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: have h : log x ≠ 0
state_before: x y : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
⊢ log x < x - 1

tactic: linarith [add_one_lt_exp_of_nonzero h, exp_log hx1]
state_before: x y : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
h : log x ≠ 0
⊢ log x < x - 1

tactic: rwa [← log_one, log_injOn_pos.ne_iff hx1]
state_before: case h
x y : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
⊢ log x ≠ 0

tactic: exact mem_Ioi.mpr zero_lt_one
state_before: case h
x y : ℝ
hx1 : 0 < x
hx2 : x ≠ 1
⊢ 1 ∈ Ioi 0
Theorem: ContinuousLinearMap.map_neg₂
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [f.map_neg, neg_apply]
state_before: 𝕜 : Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type ?u.228100
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type u_5
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type ?u.228285
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
R : Type u_1
𝕜₂ : Type u_7
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NontriviallyNormedField 𝕜₂
M : Type u_3
inst✝⁷ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_4
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜₂ G'
inst✝⁴ : NormedSpace 𝕜' G'
inst✝³ : SMulCommClass 𝕜₂ 𝕜' G'
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ρ₁₂ : R →+* 𝕜'
f : M →SL[ρ₁₂] F →SL[σ₁₂] G'
x : M
y : F
⊢ ↑(↑f (-x)) y = -↑(↑f x) y