tasksource/leandojo huggingface dataset:
Theorem: finprod_mem_eq_of_bijOn
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← Set.BijOn.image_eq he₀, finprod_mem_image he₀.2.1]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.356139
G : Type ?u.356142
M : Type u_3
N : Type ?u.356148
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → M
g : β → M
e : α → β
he₀ : BijOn e s t
he₁ : ∀ (x : α), x ∈ s → f x = g (e x)
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (j : β) (_ : j ∈ t), g j

tactic: exact finprod_mem_congr rfl he₁
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.356139
G : Type ?u.356142
M : Type u_3
N : Type ?u.356148
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → M
g : β → M
e : α → β
he₀ : BijOn e s t
he₁ : ∀ (x : α), x ∈ s → f x = g (e x)
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (j : α) (_ : j ∈ s), g (e j)
Theorem: Polynomial.coeff_C
File: Mathlib/Data/Polynomial/Basic.lean

tactic: convert coeff_monomial (a := a) (m := n) (n := 0) using 2
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ coeff (↑C a) n = if n = 0 then a else 0

tactic: simp [eq_comm]
state_before: case h.e'_3.h₁.a
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ n = 0 ↔ 0 = n
Theorem: Metric.hausdorffDist_image
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist, hausdorffEdist_image h]
state_before: ι : Sort ?u.82936
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : Isometry Φ
⊢ hausdorffDist (Φ '' s) (Φ '' t) = hausdorffDist s t
Theorem: Set.sUnion_eq_compl_sInter_compl
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← compl_compl (⋃₀S), compl_sUnion]
state_before: α : Type u_1
β : Type ?u.147561
γ : Type ?u.147564
ι : Sort ?u.147567
ι' : Sort ?u.147570
ι₂ : Sort ?u.147573
κ : ι → Sort ?u.147578
κ₁ : ι → Sort ?u.147583
κ₂ : ι → Sort ?u.147588
κ' : ι' → Sort ?u.147593
S : Set (Set α)
⊢ ⋃₀ S = (⋂₀ (compl '' S))ᶜ
Theorem: Polynomial.sum_fin
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
n : ℕ
p : R[X]
hn : degree p < ↑n
⊢ ∑ i : Fin n, f (↑i) (coeff p ↑i) = sum p f

tactic: rw [sum_over_range' _ hf n ((natDegree_lt_iff_degree_lt hp).mpr hn),
  Fin.sum_univ_eq_sum_range fun i => f i (p.coeff i)]
state_before: case neg
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
n : ℕ
p : R[X]
hn : degree p < ↑n
hp : ¬p = 0
⊢ ∑ i : Fin n, f (↑i) (coeff p ↑i) = sum p f

tactic: rw [hp, sum_zero_index, Finset.sum_eq_zero]
state_before: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
n : ℕ
p : R[X]
hn : degree p < ↑n
hp : p = 0
⊢ ∑ i : Fin n, f (↑i) (coeff p ↑i) = sum p f

tactic: intro i _
state_before: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
n : ℕ
p : R[X]
hn : degree p < ↑n
hp : p = 0
⊢ ∀ (x : Fin n), x ∈ univ → f (↑x) (coeff 0 ↑x) = 0

tactic: exact hf i
state_before: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
hf : ∀ (i : ℕ), f i 0 = 0
n : ℕ
p : R[X]
hn : degree p < ↑n
hp : p = 0
i : Fin n
a✝ : i ∈ univ
⊢ f (↑i) (coeff 0 ↑i) = 0
Theorem: Nat.Prime.multiplicity_le_multiplicity_choose_add
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: simp
state_before: p : ℕ
hp : Prime p
x✝ : ℕ
⊢ multiplicity p x✝ ≤ multiplicity p (choose x✝ 0) + multiplicity p 0

tactic: simp
state_before: p : ℕ
hp : Prime p
n✝ : ℕ
⊢ multiplicity p 0 ≤ multiplicity p (choose 0 (n✝ + 1)) + multiplicity p (n✝ + 1)

tactic: rw [← hp.multiplicity_mul]
state_before: p : ℕ
hp : Prime p
n k : ℕ
⊢ multiplicity p (n + 1) ≤ multiplicity p (choose (n + 1) (k + 1)) + multiplicity p (k + 1)

tactic: refine' multiplicity_le_multiplicity_of_dvd_right _
state_before: p : ℕ
hp : Prime p
n k : ℕ
⊢ multiplicity p (n + 1) ≤ multiplicity p (choose (n + 1) (k + 1) * (k + 1))

tactic: rw [← succ_mul_choose_eq]
state_before: p : ℕ
hp : Prime p
n k : ℕ
⊢ n + 1 ∣ choose (n + 1) (k + 1) * (k + 1)

tactic: exact dvd_mul_right _ _
state_before: p : ℕ
hp : Prime p
n k : ℕ
⊢ n + 1 ∣ succ n * choose n k
Theorem: Nat.sum_divisors_eq_sum_properDivisors_add_self
File: Mathlib/NumberTheory/Divisors.lean

tactic: rcases Decidable.eq_or_ne n 0 with (rfl | hn)
state_before: n : ℕ
⊢ ∑ i in divisors n, i = ∑ i in properDivisors n, i + n

tactic: simp
state_before: case inl

⊢ ∑ i in divisors 0, i = ∑ i in properDivisors 0, i + 0

tactic: rw [← cons_self_properDivisors hn, Finset.sum_cons, add_comm]
state_before: case inr
n : ℕ
hn : n ≠ 0
⊢ ∑ i in divisors n, i = ∑ i in properDivisors n, i + n
Theorem: Set.einfsep_pair_le_right
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [pair_comm]
state_before: α : Type u_1
β : Type ?u.27664
inst✝ : EDist α
x y : α
s t : Set α
hxy : x ≠ y
⊢ einfsep {x, y} ≤ edist y x

tactic: exact einfsep_pair_le_left hxy.symm
state_before: α : Type u_1
β : Type ?u.27664
inst✝ : EDist α
x y : α
s t : Set α
hxy : x ≠ y
⊢ einfsep {y, x} ≤ edist y x
Theorem: List.Sublist.erase
File: Std/Data/List/Lemmas.lean

tactic: simp [erase_eq_eraseP]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ List.erase l₁ a <+ List.erase l₂ a

tactic: exact Sublist.eraseP h
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ List.eraseP (fun b => decide (a = b)) l₁ <+ List.eraseP (fun b => decide (a = b)) l₂
Theorem: ENNReal.ofReal_le_ofReal_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.ofReal, ENNReal.ofReal, coe_le_coe, Real.toNNReal_le_toNNReal_iff h]
state_before: α : Type ?u.806432
β : Type ?u.806435
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
h : 0 ≤ q
⊢ ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q
Theorem: List.mem_map_swap
File: Mathlib/Data/List/Basic.lean

tactic: induction' xs with x xs xs_ih
state_before: ι : Type ?u.491056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
y : β
xs : List (α × β)
⊢ (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs

tactic: simp only [not_mem_nil, map_nil]
state_before: case nil
ι : Type ?u.491056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
y : β
⊢ (y, x) ∈ map Prod.swap [] ↔ (x, y) ∈ []

tactic: cases' x with a b
state_before: case cons
ι : Type ?u.491056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ : α
y : β
x : α × β
xs : List (α × β)
xs_ih : (y, x✝) ∈ map Prod.swap xs ↔ (x✝, y) ∈ xs
⊢ (y, x✝) ∈ map Prod.swap (x :: xs) ↔ (x✝, y) ∈ x :: xs

tactic: simp only [mem_cons, Prod.mk.inj_iff, map, Prod.swap_prod_mk, Prod.exists, xs_ih, and_comm]
state_before: case cons.mk
ι : Type ?u.491056
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
y : β
xs : List (α × β)
xs_ih : (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs
a : α
b : β
⊢ (y, x) ∈ map Prod.swap ((a, b) :: xs) ↔ (x, y) ∈ (a, b) :: xs
Theorem: Module.End.ker_pow_eq_ker_pow_finrank_of_le
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: obtain ⟨k, h_k_le, hk⟩ :
  ∃ k, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ) :=
  exists_ker_pow_eq_ker_pow_succ f
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ finrank K V)

tactic: calc
  LinearMap.ker (f ^ m) = LinearMap.ker (f ^ (k + (m - k))) := by
    rw [add_tsub_cancel_of_le (h_k_le.trans hm)]
  _ = LinearMap.ker (f ^ k) := by rw [ker_pow_constant hk _]
  _ = LinearMap.ker (f ^ (k + (finrank K V - k))) := (ker_pow_constant hk (finrank K V - k))
  _ = LinearMap.ker (f ^ finrank K V) := by rw [add_tsub_cancel_of_le h_k_le]
state_before: case intro.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ finrank K V)

tactic: rw [add_tsub_cancel_of_le (h_k_le.trans hm)]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ (k + (m - k)))

tactic: rw [ker_pow_constant hk _]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ (k + (m - k))) = LinearMap.ker (f ^ k)

tactic: rw [add_tsub_cancel_of_le h_k_le]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ (k + (finrank K V - k))) = LinearMap.ker (f ^ finrank K V)
Theorem: SimpleGraph.Subgraph.neighborSet_iSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iSup]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
f : ι → Subgraph G
v : V
⊢ neighborSet (⨆ (i : ι), f i) v = ⋃ (i : ι), neighborSet (f i) v
Theorem: set_has_minimal_iff_artinian
File: Mathlib/RingTheory/Artinian.lean

tactic: rw [isArtinian_iff_wellFounded, WellFounded.wellFounded_iff_has_min]
state_before: R : Type u_2
M : Type u_1
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (a : Set (Submodule R M)), Set.Nonempty a → ∃ M', M' ∈ a ∧ ∀ (I : Submodule R M), I ∈ a → ¬I < M') ↔ IsArtinian R M
Theorem: Finset.filter_eq'
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [@eq_comm _ b]
state_before: α : Type ?u.411231
β : Type u_1
γ : Type ?u.411237
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b x✝¹ : β
x✝ : x✝¹ ∈ s
⊢ x✝¹ = b ↔ b = x✝¹
Theorem: PiNat.dist_nonneg
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rcases eq_or_ne x y with (rfl | h)
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ 0 ≤ dist x y

tactic: simp [dist]
state_before: case inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ 0 ≤ dist x x

tactic: simp [dist, h, zero_le_two]
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ 0 ≤ dist x y
Theorem: FreeMonoid.hom_eq
File: Mathlib/Algebra/FreeMonoid/Basic.lean

tactic: simp only [h, hxs, MonoidHom.map_mul]
state_before: α : Type u_1
β : Type ?u.22031
γ : Type ?u.22034
M : Type u_2
inst✝¹ : Monoid M
N : Type ?u.22043
inst✝ : Monoid N
f g : FreeMonoid α →* M
h : ∀ (x : α), ↑f (of x) = ↑g (of x)
l : FreeMonoid α
x : α
xs : FreeMonoid α
hxs : ↑f xs = ↑g xs
⊢ ↑f (of x * xs) = ↑g (of x * xs)
Theorem: measurable_inv_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_inv] using h.inv
state_before: G✝ : Type ?u.2420648
α : Type u_2
inst✝⁵ : Inv G✝
inst✝⁴ : MeasurableSpace G✝
inst✝³ : MeasurableInv G✝
m : MeasurableSpace α
f✝ : α → G✝
μ : MeasureTheory.Measure α
G : Type u_1
inst✝² : Group G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableInv G
f : α → G
h : Measurable fun x => (f x)⁻¹
⊢ Measurable f
Theorem: Finset.filter_gt_eq_Iio
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.67690
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x < a
⊢ filter (fun x => x < a) univ = Iio a

tactic: simp
state_before: case a
ι : Type ?u.67690
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x < a
a✝ : α
⊢ a✝ ∈ filter (fun x => x < a) univ ↔ a✝ ∈ Iio a
Theorem: FreeLieAlgebra.Rel.addLeft
File: Mathlib/Algebra/Lie/Free.lean

tactic: rw [add_comm _ b, add_comm _ c]
state_before: R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (a + b) (a + c)

tactic: exact h.add_right _
state_before: R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (b + a) (c + a)
Theorem: LocalHomeomorph.restr_toLocalEquiv'
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [e.restr_toLocalEquiv, hs.interior_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.53706
δ : Type ?u.53709
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
hs : IsOpen s
⊢ (LocalHomeomorph.restr e s).toLocalEquiv = LocalEquiv.restr e.toLocalEquiv s
Theorem: Nat.succ_mod_two_add_mod_two
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [add_comm, mod_two_add_succ_mod_two]
state_before: m✝ n m : ℕ
⊢ (m + 1) % 2 + m % 2 = 1
Theorem: TopCat.Presheaf.id_pushforward
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: apply CategoryTheory.Functor.ext
state_before: C : Type u
inst✝ : Category C
X : TopCat
⊢ pushforward C (𝟙 X) = 𝟭 (Presheaf C X)

tactic: intros a b f
state_before: case h_map
C : Type u
inst✝ : Category C
X : TopCat
⊢ autoParam
    (∀ (X_1 Y : Presheaf C X) (f : X_1 ⟶ Y),
      (pushforward C (𝟙 X)).map f =
        eqToHom (_ : ?F.obj X_1 = ?G.obj X_1) ≫
          (𝟭 (Presheaf C X)).map f ≫ eqToHom (_ : (𝟭 (Presheaf C X)).obj Y = (pushforward C (𝟙 X)).obj Y))
    _auto✝

tactic: refine NatTrans.ext _ _ (funext fun U => ?_)
state_before: case h_map
C : Type u
inst✝ : Category C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
⊢ (pushforward C (𝟙 X)).map f =
    eqToHom (_ : ?F.obj a = ?G.obj a) ≫
      (𝟭 (Presheaf C X)).map f ≫ eqToHom (_ : (𝟭 (Presheaf C X)).obj b = (pushforward C (𝟙 X)).obj b)

tactic: . erw [NatTrans.congr f (Opens.op_map_id_obj U)]
  simp only [Functor.op_obj, eqToHom_refl, CategoryTheory.Functor.map_id,
    Category.comp_id, Category.id_comp, Functor.id_obj, Functor.id_map]
  apply Pushforward.id_eq
state_before: case h_map
C : Type u
inst✝ : Category C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : (Opens ↑X)ᵒᵖ
⊢ ((pushforward C (𝟙 X)).map f).app U =
    (eqToHom (_ : ?F.obj a = ?G.obj a) ≫
          (𝟭 (Presheaf C X)).map f ≫ eqToHom (_ : (𝟭 (Presheaf C X)).obj b = (pushforward C (𝟙 X)).obj b)).app
      U

tactic: erw [NatTrans.congr f (Opens.op_map_id_obj U)]
state_before: case h_map
C : Type u
inst✝ : Category C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : (Opens ↑X)ᵒᵖ
⊢ ((pushforward C (𝟙 X)).map f).app U =
    (eqToHom (_ : ?F.obj a = ?G.obj a) ≫
          (𝟭 (Presheaf C X)).map f ≫ eqToHom (_ : (𝟭 (Presheaf C X)).obj b = (pushforward C (𝟙 X)).obj b)).app
      U

tactic: simp only [Functor.op_obj, eqToHom_refl, CategoryTheory.Functor.map_id,
  Category.comp_id, Category.id_comp, Functor.id_obj, Functor.id_map]
state_before: case h_map
C : Type u
inst✝ : Category C
X : TopCat
a b : Presheaf C X
f : a ⟶ b
U : (Opens ↑X)ᵒᵖ
⊢ a.map (eqToHom (_ : (Functor.op (Opens.map (𝟙 X))).obj U = U)) ≫
      f.app U ≫ b.map (eqToHom (_ : U = (Functor.op (Opens.map (𝟙 X))).obj U)) =
    (eqToHom (_ : ?F.obj a = ?G.obj a) ≫
          (𝟭 (Presheaf C X)).map f ≫ eqToHom (_ : (𝟭 (Presheaf C X)).obj b = (pushforward C (𝟙 X)).obj b)).app
      U

case h_obj
C : Type u
inst✝ : Category C
X : TopCat
⊢ ∀ (X_1 : Presheaf C X), (pushforward C (𝟙 X)).obj X_1 = (𝟭 (Presheaf C X)).obj X_1

tactic: apply Pushforward.id_eq
state_before: case h_obj
C : Type u
inst✝ : Category C
X : TopCat
⊢ ∀ (X_1 : Presheaf C X), (pushforward C (𝟙 X)).obj X_1 = (𝟭 (Presheaf C X)).obj X_1
Theorem: Polynomial.taylor_injective
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: intro f g h
state_before: R✝ : Type ?u.225297
inst✝¹ : Semiring R✝
r✝ : R✝
f : R✝[X]
R : Type u_1
inst✝ : CommRing R
r : R
⊢ Function.Injective ↑(taylor r)

tactic: apply_fun taylor (-r) at h
state_before: R✝ : Type ?u.225297
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
r : R
f g : R[X]
h : ↑(taylor r) f = ↑(taylor r) g
⊢ f = g

tactic: simpa only [taylor_apply, comp_assoc, add_comp, X_comp, C_comp, C_neg, neg_add_cancel_right,
  comp_X] using h
state_before: R✝ : Type ?u.225297
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
r : R
f g : R[X]
h : ↑(taylor (-r)) (↑(taylor r) f) = ↑(taylor (-r)) (↑(taylor r) g)
⊢ f = g
Theorem: Int.neg_le_of_neg_le
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.neg_le_neg h
state_before: a b : Int
h : -a ≤ b
⊢ -b ≤ a

tactic: rwa [Int.neg_neg] at h
state_before: a b : Int
h✝ : -a ≤ b
h : -b ≤ - -a
⊢ -b ≤ a
Theorem: Turing.TM2to1.addBottom_nth_succ_fst
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [ListBlank.nth_succ, addBottom, ListBlank.tail_cons, ListBlank.nth_map]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.603198
inst✝¹ : Inhabited Λ
σ : Type ?u.603204
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
n : ℕ
⊢ (ListBlank.nth (addBottom L) (n + 1)).fst = false
Theorem: Monoid.lcm_order_eq_exponent
File: Mathlib/GroupTheory/Exponent.lean

tactic: apply Nat.dvd_antisymm (lcm_orderOf_dvd_exponent G)
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ Finset.lcm Finset.univ orderOf = exponent G

tactic: refine' exponent_dvd_of_forall_pow_eq_one G _ fun g => _
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ exponent G ∣ Finset.lcm Finset.univ orderOf

tactic: obtain ⟨m, hm⟩ : orderOf g ∣ Finset.univ.lcm orderOf := Finset.dvd_lcm (Finset.mem_univ g)
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
⊢ g ^ Finset.lcm Finset.univ orderOf = 1

tactic: rw [hm, pow_mul, pow_orderOf_eq_one, one_pow]
state_before: case intro
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
m : ℕ
hm : Finset.lcm Finset.univ orderOf = orderOf g * m
⊢ g ^ Finset.lcm Finset.univ orderOf = 1
Theorem: Polynomial.Monic.add_of_right
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rwa [Monic, leadingCoeff_add_of_degree_lt hpq]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hq : Monic q
hpq : degree p < degree q
⊢ Monic (p + q)
Theorem: Multiset.lcm_dvd
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ lcm 0 ∣ a ↔ ∀ (b : α), b ∈ 0 → b ∣ a

tactic: simp (config := { contextual := true }) [or_imp, forall_and, lcm_dvd_iff]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
a : α
⊢ ∀ ⦃a_1 : α⦄ {s : Multiset α},
    (lcm s ∣ a ↔ ∀ (b : α), b ∈ s → b ∣ a) → (lcm (a_1 ::ₘ s) ∣ a ↔ ∀ (b : α), b ∈ a_1 ::ₘ s → b ∣ a)
Theorem: Set.pairwise_univ
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [Set.Pairwise, Pairwise, mem_univ, forall_const]
state_before: α : Type u_1
β : Type ?u.16480
γ : Type ?u.16483
ι : Type ?u.16486
ι' : Type ?u.16489
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
⊢ Set.Pairwise univ r ↔ Pairwise r
Theorem: Filter.principal_mono
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [le_principal_iff, iff_self_iff, mem_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.77623
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s ≤ 𝓟 t ↔ s ⊆ t
Theorem: Real.diam_Ioc
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [Metric.diam, ENNReal.toReal_ofReal (sub_nonneg.2 h)]
state_before: α : Type ?u.564058
β : Type ?u.564061
γ : Type ?u.564064
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a ≤ b
⊢ Metric.diam (Ioc a b) = b - a
Theorem: Stream'.WSeq.head_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [head]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ head ↑s = Computation.pure (Seq.head s)

tactic: cases Seq.head s <;> rfl
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Computation.pure (Option.map (Prod.fst ∘ fun a => (a, ↑(Seq.tail s))) (Seq.head s)) = Computation.pure (Seq.head s)
Theorem: geom_goldConj_isSol_fibRec
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec.geom_sol_iff_root_charPoly, fibRec_charPoly_eq]
state_before: α : Type ?u.59403
inst✝ : CommSemiring α
⊢ LinearRecurrence.IsSolution fibRec fun x => ψ ^ x

tactic: simp [sub_eq_zero, - div_pow]
state_before: α : Type ?u.59403
inst✝ : CommSemiring α
⊢ IsRoot (X ^ 2 - (X + 1)) ψ
Theorem: ZMod.χ₄_int_three_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [χ₄_int_mod_four, hn]
state_before: n : ℤ
hn : n % 4 = 3
⊢ ↑χ₄ ↑n = -1

tactic: rfl
state_before: n : ℤ
hn : n % 4 = 3
⊢ ↑χ₄ ↑3 = -1
Theorem: and_symm_right
File: Mathlib/Logic/Basic.lean

tactic: simp [eq_comm]
state_before: α : Sort u_1
a b : α
p : Prop
⊢ p ∧ a = b ↔ p ∧ b = a
Theorem: LinearMap.toMatrix₂Aux_eq
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [LinearMap.toMatrix₂_apply, LinearMap.toMatrix₂Aux_apply]
state_before: R : Type u_1
R₁ : Type ?u.1372557
R₂ : Type ?u.1372560
M : Type ?u.1372563
M₁ : Type u_2
M₂ : Type u_3
M₁' : Type ?u.1372572
M₂' : Type ?u.1372575
n : Type u_4
m : Type u_5
n' : Type ?u.1372584
m' : Type ?u.1372587
ι : Type ?u.1372590
inst✝⁸ : CommRing R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : M₁ →ₗ[R] M₂ →ₗ[R] R
i : n
j : m
⊢ ↑(toMatrix₂Aux ↑b₁ ↑b₂) B i j = ↑(toMatrix₂ b₁ b₂) B i j
Theorem: Commute.multiset_sum_right
File: Mathlib/Algebra/BigOperators/Multiset/Lemmas.lean

tactic: induction s using Quotient.inductionOn
state_before: α : Type u_1
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
h : ∀ (b : α), b ∈ s → Commute a b
⊢ Commute a (sum s)

tactic: rw [quot_mk_to_coe, coe_sum]
state_before: case h
α : Type u_1
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ (b : α), b ∈ Quotient.mk (List.isSetoid α) a✝ → Commute a b
⊢ Commute a (sum (Quotient.mk (List.isSetoid α) a✝))

tactic: exact Commute.list_sum_right _ _ h
state_before: case h
α : Type u_1
inst✝ : NonUnitalNonAssocSemiring α
s : Multiset α
a : α
a✝ : List α
h : ∀ (b : α), b ∈ Quotient.mk (List.isSetoid α) a✝ → Commute a b
⊢ Commute a (List.sum a✝)
Theorem: Real.Angle.sign_coe_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sin_coe, sin_pi_div_two, sign_one]
state_before: ⊢ sign ↑(π / 2) = 1
Theorem: Finset.map_add_right_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Icc, coe_Icc]
state_before: ι : Type ?u.213211
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Icc a b) = Icc (a + c) (b + c)

tactic: exact Set.image_add_const_Icc _ _ _
state_before: ι : Type ?u.213211
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addRightEmbedding c) '' Set.Icc a b = Set.Icc (a + c) (b + c)
Theorem: Nat.add_eq_min_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [← max_eq_zero_iff]
state_before: m n k l : ℕ
⊢ m + n = min m n ↔ m = 0 ∧ n = 0

tactic: cases' le_total m n with H H <;> simp [H]
state_before: m n k l : ℕ
⊢ m + n = min m n ↔ max m n = 0
Theorem: Option.eq_some_iff_get_eq
File: Std/Data/Option/Lemmas.lean

tactic: cases o <;> simp
state_before: α✝ : Type u_1
o : Option α✝
a : α✝
⊢ o = some a ↔ ∃ h, get o h = a

tactic: intro.
state_before: case none
α✝ : Type u_1
a : α✝
⊢ ∀ (x : false = true), ¬get none x = a