tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.IsKernelPair.of_isIso_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean

tactic: change IsPullback _ _ _ _
state_before: C : Type u
inst✝² : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ IsKernelPair f a a

tactic: convert (IsPullback.of_horiz_isIso ⟨(rfl : a ≫ 𝟙 X = _ )⟩).paste_vert (IsKernelPair.id_of_mono f)
state_before: C : Type u
inst✝² : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ IsPullback a a f f

tactic: all_goals { simp }
state_before: case h.e'_8
C : Type u
inst✝² : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ a = a ≫ 𝟙 X

case h.e'_9
C : Type u
inst✝² : Category C
R X Y Z : C
f : X ⟶ Y
a b : R ⟶ X
inst✝¹ : IsIso a
inst✝ : Mono f
⊢ f = 𝟙 X ≫ f
Theorem: SimpleGraph.Walk.isCircuit_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''
u u' : V
p : Walk G u u
hu : u = u'
⊢ IsCircuit (Walk.copy p hu hu) ↔ IsCircuit p

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' : V
p : Walk G u' u'
⊢ IsCircuit (Walk.copy p (_ : u' = u') (_ : u' = u')) ↔ IsCircuit p
Theorem: Subsingleton.pi_mulSingle_eq
File: Mathlib/Data/Pi/Algebra.lean

tactic: rw [Subsingleton.elim j i, Pi.mulSingle_eq_same]
state_before: I : Type u
α✝ : Type ?u.35145
β : Type ?u.35148
γ : Type ?u.35151
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
α : Type u_1
inst✝² : DecidableEq I
inst✝¹ : Subsingleton I
inst✝ : One α
i : I
x : α
j : I
⊢ Pi.mulSingle i x j = x
Theorem: Filter.inf_eq_bot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [← disjoint_iff, Filter.disjoint_iff, Set.disjoint_iff_inter_eq_empty]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.86298
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ f ⊓ g = ⊥ ↔ ∃ U, U ∈ f ∧ ∃ V, V ∈ g ∧ U ∩ V = ∅
Theorem: Commute.isNilpotent_mul_left
File: Mathlib/RingTheory/Nilpotent.lean

tactic: obtain ⟨n, hn⟩ := h
state_before: R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
h : IsNilpotent x
⊢ IsNilpotent (x * y)

tactic: use n
state_before: case intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
⊢ IsNilpotent (x * y)

tactic: rw [h_comm.mul_pow, hn, MulZeroClass.zero_mul]
state_before: case intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
⊢ (x * y) ^ n = 0
Theorem: Filter.IsBasis.filter_eq_generate
File: Mathlib/Order/Filter/Bases.lean

tactic: erw [h.filterBasis.generate]
state_before: α : Type u_1
β : Type ?u.9602
γ : Type ?u.9605
ι : Sort u_2
ι' : Sort ?u.9611
p : ι → Prop
s : ι → Set α
h : IsBasis p s
⊢ IsBasis.filter h = generate {U | ∃ i, p i ∧ s i = U}

tactic: rfl
state_before: α : Type u_1
β : Type ?u.9602
γ : Type ?u.9605
ι : Sort u_2
ι' : Sort ?u.9611
p : ι → Prop
s : ι → Set α
h : IsBasis p s
⊢ IsBasis.filter h = FilterBasis.filter (IsBasis.filterBasis h)
Theorem: geom_sum_mul_neg
File: Mathlib/Algebra/GeomSum.lean

tactic: have := congr_arg Neg.neg (geom_sum_mul x n)
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
⊢ (∑ i in range n, x ^ i) * (1 - x) = 1 - x ^ n

tactic: rw [neg_sub, ← mul_neg, neg_sub] at this
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : -((∑ i in range n, x ^ i) * (x - 1)) = -(x ^ n - 1)
⊢ (∑ i in range n, x ^ i) * (1 - x) = 1 - x ^ n

tactic: exact this
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : (∑ i in range n, x ^ i) * (1 - x) = 1 - x ^ n
⊢ (∑ i in range n, x ^ i) * (1 - x) = 1 - x ^ n
Theorem: Polynomial.eval_eq_sum_range
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval_eq_sum, sum_over_range]
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]
x✝ : R
p : R[X]
x : R
⊢ eval x p = ∑ i in range (natDegree p + 1), coeff p i * x ^ i

tactic: simp
state_before: case h
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
x : R
⊢ ∀ (n : ℕ), 0 * x ^ n = 0
Theorem: Array.get?_push_lt
File: Std/Data/Array/Lemmas.lean

tactic: rw [getElem?_pos, get_push_lt]
state_before: α : Type u_1
a : Array α
x : α
i : Nat
h : i < size a
⊢ (push a x)[i]? = some a[i]
Theorem: extChartAt_preimage_inter_eq
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: mfld_set_tac
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.225289
M' : Type ?u.225292
H' : Type ?u.225295
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
⊢ ↑(LocalEquiv.symm (extChartAt I x)) ⁻¹' (s ∩ t) ∩ range ↑I =
    ↑(LocalEquiv.symm (extChartAt I x)) ⁻¹' s ∩ range ↑I ∩ ↑(LocalEquiv.symm (extChartAt I x)) ⁻¹' t
Theorem: WittVector.mapFun.zero
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.30320
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.30335
β : Type ?u.30338
f : R →+* S
x y : 𝕎 R
⊢ mapFun (↑f) 0 = 0
Theorem: Nat.sqrt_succ_le_succ_sqrt
File: Mathlib/Data/Nat/Sqrt.lean

tactic: refine' add_le_add (Nat.mul_le_mul_right _ _) _ <;> exact Nat.le_add_right _ 2
state_before: n : ℕ
⊢ sqrt n * sqrt n + sqrt n ≤ Nat.mul (succ (succ (sqrt n))) (succ (sqrt n))
Theorem: Heyting.IsRegular.disjoint_compl_right_iff
File: Mathlib/Order/Heyting/Regular.lean

tactic: rw [← le_compl_iff_disjoint_right, hb.eq]
state_before: α : Type u_1
inst✝ : HeytingAlgebra α
a b : α
hb : IsRegular b
⊢ Disjoint a (bᶜ) ↔ a ≤ b
Theorem: SimpleGraph.end_hom_mk_of_mk
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rw [← sec h, hs]
state_before: V : Type u
G : SimpleGraph V
K✝ L✝ L' M : Set V
s : (j : (Finset V)ᵒᵖ) → (componentComplFunctor G).obj j
sec : s ∈ SimpleGraph.end G
K L : (Finset V)ᵒᵖ
h : L ⟶ K
v : V
vnL : ¬v ∈ L.unop
hs : s L = componentComplMk G vnL
⊢ s K = componentComplMk G (_ : ¬v ∈ fun a => a ∈ K.unop.val)

tactic: apply ComponentCompl.hom_mk _ (le_of_op_hom h : _ ⊆ _)
state_before: V : Type u
G : SimpleGraph V
K✝ L✝ L' M : Set V
s : (j : (Finset V)ᵒᵖ) → (componentComplFunctor G).obj j
sec : s ∈ SimpleGraph.end G
K L : (Finset V)ᵒᵖ
h : L ⟶ K
v : V
vnL : ¬v ∈ L.unop
hs : s L = componentComplMk G vnL
⊢ (componentComplFunctor G).map h (componentComplMk G vnL) = componentComplMk G (_ : ¬v ∈ fun a => a ∈ K.unop.val)
Theorem: Nat.div_two_mul_two_add_one_of_odd
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [← odd_iff.mp h, div_add_mod']
state_before: m n : ℕ
h : Odd n
⊢ n / 2 * 2 + 1 = n
Theorem: IsUnit.of_leftInverse
File: Mathlib/Algebra/Hom/Units.lean

tactic: simpa only [hfg x] using h.map g
state_before: F : Type u_1
G : Type u_4
α : Type ?u.38455
M : Type u_2
N : Type u_3
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : MonoidHomClass F M N
inst✝ : MonoidHomClass G N M
f : F
x : M
g : G
hfg : LeftInverse ↑g ↑f
h : IsUnit (↑f x)
⊢ IsUnit x
Theorem: MeasureTheory.FiniteMeasure.zero_testAgainstNN_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simp only [testAgainstNN, toMeasure_zero, lintegral_zero_measure, ENNReal.zero_toNNReal]
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type ?u.53064
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
f : Ω →ᵇ ℝ≥0
⊢ testAgainstNN 0 f = 0
Theorem: HasFPowerSeriesOnBall.eventually_hasSum_sub
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: filter_upwards [EMetric.ball_mem_nhds x hf.r_pos] with y using hf.hasSum_sub
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.458834
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
⊢ ∀ᶠ (y : E) in 𝓝 x, HasSum (fun n => ↑(p n) fun x_1 => y - x) (f y)
Theorem: Finset.prod_eraseNone
File: Mathlib/Algebra/BigOperators/Option.lean

tactic: classical calc
    (∏ x in eraseNone s, f x) = ∏ x in (eraseNone s).map Embedding.some, Option.elim' 1 f x :=
      (prod_map (eraseNone s) Embedding.some <| Option.elim' 1 f).symm
    _ = ∏ x in s.erase none, Option.elim' 1 f x := by rw [map_some_eraseNone]
    _ = ∏ x in s, Option.elim' 1 f x := prod_erase _ rfl
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
f : α → M
s : Finset (Option α)
⊢ ∏ x in ↑eraseNone s, f x = ∏ x in s, Option.elim' 1 f x

tactic: calc
(∏ x in eraseNone s, f x) = ∏ x in (eraseNone s).map Embedding.some, Option.elim' 1 f x :=
(prod_map (eraseNone s) Embedding.some <| Option.elim' 1 f).symm
_ = ∏ x in s.erase none, Option.elim' 1 f x := by rw [map_some_eraseNone]
_ = ∏ x in s, Option.elim' 1 f x := prod_erase _ rfl
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
f : α → M
s : Finset (Option α)
⊢ ∏ x in ↑eraseNone s, f x = ∏ x in s, Option.elim' 1 f x

tactic: rw [map_some_eraseNone]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
f : α → M
s : Finset (Option α)
⊢ ∏ x in map Embedding.some (↑eraseNone s), Option.elim' 1 f x = ∏ x in erase s none, Option.elim' 1 f x
Theorem: IsSubmonoid.preimage
File: Mathlib/Deprecated/Submonoid.lean

tactic: (rw [IsMonoidHom.map_one hf]; exact hs.one_mem)
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
⊢ f 1 ∈ s

tactic: rw [IsMonoidHom.map_one hf]
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
⊢ f 1 ∈ s

tactic: exact hs.one_mem
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
⊢ 1 ∈ s

tactic: (rw [IsMonoidHom.map_mul' hf]; exact hs.mul_mem ha hb)
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
a b : M
ha : f a ∈ s
hb : f b ∈ s
⊢ f (a * b) ∈ s

tactic: rw [IsMonoidHom.map_mul' hf]
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
a b : M
ha : f a ∈ s
hb : f b ∈ s
⊢ f (a * b) ∈ s

tactic: exact hs.mul_mem ha hb
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A : Type ?u.24553
inst✝¹ : AddMonoid A
t : Set A
N : Type u_1
inst✝ : Monoid N
f : M → N
hf : IsMonoidHom f
s : Set N
hs : IsSubmonoid s
a b : M
ha : f a ∈ s
hb : f b ∈ s
⊢ f a * f b ∈ s
Theorem: List.Sorted.rel_of_mem_take_of_mem_drop
File: Mathlib/Data/List/Sort.lean

tactic: obtain ⟨⟨iy, hiy⟩, rfl⟩ := get_of_mem hy
state_before: α : Type uu
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x y : α
hx : x ∈ take k l
hy : y ∈ drop k l
⊢ r x y

tactic: obtain ⟨⟨ix, hix⟩, rfl⟩ := get_of_mem hx
state_before: case intro.mk
α : Type uu
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x : α
hx : x ∈ take k l
iy : ℕ
hiy : iy < length (drop k l)
hy : get (drop k l) { val := iy, isLt := hiy } ∈ drop k l
⊢ r x (get (drop k l) { val := iy, isLt := hiy })

tactic: rw [get_take', get_drop']
state_before: case intro.mk.intro.mk
α : Type uu
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < length (drop k l)
hy : get (drop k l) { val := iy, isLt := hiy } ∈ drop k l
ix : ℕ
hix : ix < length (take k l)
hx : get (take k l) { val := ix, isLt := hix } ∈ take k l
⊢ r (get (take k l) { val := ix, isLt := hix }) (get (drop k l) { val := iy, isLt := hiy })

tactic: rw [length_take] at hix
state_before: case intro.mk.intro.mk
α : Type uu
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < length (drop k l)
hy : get (drop k l) { val := iy, isLt := hiy } ∈ drop k l
ix : ℕ
hix : ix < length (take k l)
hx : get (take k l) { val := ix, isLt := hix } ∈ take k l
⊢ r (get l { val := ↑{ val := ix, isLt := hix }, isLt := (_ : ↑{ val := ix, isLt := hix } < length l) })
    (get l { val := k + ↑{ val := iy, isLt := hiy }, isLt := (_ : k + ↑{ val := iy, isLt := hiy } < length l) })

tactic: exact h.rel_nthLe_of_lt _ _ (ix.lt_add_right _ _ (lt_min_iff.mp hix).left)
state_before: case intro.mk.intro.mk
α : Type uu
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < length (drop k l)
hy : get (drop k l) { val := iy, isLt := hiy } ∈ drop k l
ix : ℕ
hix✝ : ix < length (take k l)
hix : ix < min k (length l)
hx : get (take k l) { val := ix, isLt := hix✝ } ∈ take k l
⊢ r (get l { val := ↑{ val := ix, isLt := hix✝ }, isLt := (_ : ↑{ val := ix, isLt := hix✝ } < length l) })
    (get l { val := k + ↑{ val := iy, isLt := hiy }, isLt := (_ : k + ↑{ val := iy, isLt := hiy } < length l) })
Theorem: MeasureTheory.withDensity_mul
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.1814114
γ : Type ?u.1814117
δ : Type ?u.1814120
m m0 : MeasurableSpace α
μ : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
⊢ Measure.withDensity μ (f * g) = Measure.withDensity (Measure.withDensity μ f) g

tactic: simp [withDensity_apply _ hs, restrict_withDensity hs,
  lintegral_withDensity_eq_lintegral_mul _ hf hg]
state_before: case h
α : Type u_1
β : Type ?u.1814114
γ : Type ?u.1814117
δ : Type ?u.1814120
m m0 : MeasurableSpace α
μ : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
hs : MeasurableSet s
⊢ ↑↑(Measure.withDensity μ (f * g)) s = ↑↑(Measure.withDensity (Measure.withDensity μ f) g) s
Theorem: MvPolynomial.support_symmDiff_support_subset_support_add
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [symmDiff_def, Finset.sup_eq_union]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support p ∆ support q ⊆ support (p + q)

tactic: apply Finset.union_subset
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support p \ support q ∪ support q \ support p ⊆ support (p + q)

tactic: exact support_sdiff_support_subset_support_add p q
state_before: case hs
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support p \ support q ⊆ support (p + q)

tactic: rw [add_comm]
state_before: case a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support q \ support p ⊆ support (p + q)

tactic: exact support_sdiff_support_subset_support_add q p
state_before: case a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
⊢ support q \ support p ⊆ support (q + p)
Theorem: EuclideanDomain.xgcdAux_fst
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: intros
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
⊢ ∀ (x s t s' t' : R), (xgcdAux 0 s t x s' t').fst = gcd 0 x

tactic: rw [xgcd_zero_left, gcd_zero_left]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y x✝ s✝ t✝ s'✝ t'✝ : R
⊢ (xgcdAux 0 s✝ t✝ x✝ s'✝ t'✝).fst = gcd 0 x✝

tactic: simp only [xgcdAux_rec h, if_neg h, IH]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x✝ y✝ x y : R
h : x ≠ 0
IH : ∀ (s t s' t' : R), (xgcdAux (y % x) s t x s' t').fst = gcd (y % x) x
s t s' t' : R
⊢ (xgcdAux x s t y s' t').fst = gcd x y

tactic: rw [← gcd_val]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x✝ y✝ x y : R
h : x ≠ 0
IH : ∀ (s t s' t' : R), (xgcdAux (y % x) s t x s' t').fst = gcd (y % x) x
s t s' t' : R
⊢ gcd (y % x) x = gcd x y
Theorem: CategoryTheory.GrothendieckTopology.sheafificationWhiskerLeftIso_hom_app
File: Mathlib/CategoryTheory/Sites/CompatibleSheafification.lean

tactic: dsimp [sheafificationWhiskerLeftIso, sheafifyCompIso]
state_before: C : Type u
inst✝¹⁰ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category D
E : Type w₂
inst✝⁸ : Category E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (sheafificationWhiskerLeftIso J P).hom.app F = (sheafifyCompIso J F P).hom

tactic: rw [Category.comp_id]
state_before: C : Type u
inst✝¹⁰ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category D
E : Type w₂
inst✝⁸ : Category E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom ≫ 𝟙 (plusObj J (plusObj J (P ⋙ F))) =
    (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom
Theorem: abs_sub_le_iff
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_le, neg_le_sub_iff_le_add, sub_le_iff_le_add', and_comm, sub_le_iff_le_add']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ abs (a - b) ≤ c ↔ a - b ≤ c ∧ b - a ≤ c
Theorem: MonoidAlgebra.mem_span_support
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: erw [of, MonoidHom.coe_mk, ← supported_eq_span_single, Finsupp.mem_supported]
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : MulOneClass G
f : MonoidAlgebra k G
⊢ f ∈ Submodule.span k (↑(of k G) '' ↑f.support)
Theorem: div_neg_eq_neg_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← inv_eq_one_div, division_def]
state_before: α : Type ?u.27142
β : Type ?u.27145
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b / -a = b * (1 / -a)

tactic: rw [one_div_neg_eq_neg_one_div]
state_before: α : Type ?u.27142
β : Type ?u.27145
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b * (1 / -a) = b * -(1 / a)

tactic: rw [neg_mul_eq_mul_neg]
state_before: α : Type ?u.27142
β : Type ?u.27145
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b * -(1 / a) = -(b * (1 / a))

tactic: rw [mul_one_div]
state_before: α : Type ?u.27142
β : Type ?u.27145
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -(b * (1 / a)) = -(b / a)
Theorem: CategoryTheory.transferNatTransSelf_comp
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: ext
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
g : L₃ ⟶ L₂
⊢ ↑(transferNatTransSelf adj₁ adj₂) f ≫ ↑(transferNatTransSelf adj₂ adj₃) g = ↑(transferNatTransSelf adj₁ adj₃) (g ≫ f)

tactic: dsimp [transferNatTransSelf, transferNatTrans]
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
g : L₃ ⟶ L₂
x✝ : D
⊢ (↑(transferNatTransSelf adj₁ adj₂) f ≫ ↑(transferNatTransSelf adj₂ adj₃) g).app x✝ =
    (↑(transferNatTransSelf adj₁ adj₃) (g ≫ f)).app x✝

tactic: simp only [id_comp, comp_id]
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
g : L₃ ⟶ L₂
x✝ : D
⊢ (𝟙 (R₁.obj x✝) ≫
        (adj₂.unit.app (R₁.obj x✝) ≫
            R₂.map ((𝟙 (L₂.obj (R₁.obj x✝)) ≫ f.app (R₁.obj x✝) ≫ 𝟙 (L₁.obj (R₁.obj x✝))) ≫ adj₁.counit.app x✝)) ≫
          𝟙 (R₂.obj x✝)) ≫
      𝟙 (R₂.obj x✝) ≫
        (adj₃.unit.app (R₂.obj x✝) ≫
            R₃.map ((𝟙 (L₃.obj (R₂.obj x✝)) ≫ g.app (R₂.obj x✝) ≫ 𝟙 (L₂.obj (R₂.obj x✝))) ≫ adj₂.counit.app x✝)) ≫
          𝟙 (R₃.obj x✝) =
    𝟙 (R₁.obj x✝) ≫
      (adj₃.unit.app (R₁.obj x✝) ≫
          R₃.map
            ((𝟙 (L₃.obj (R₁.obj x✝)) ≫ (g.app (R₁.obj x✝) ≫ f.app (R₁.obj x✝)) ≫ 𝟙 (L₁.obj (R₁.obj x✝))) ≫
              adj₁.counit.app x✝)) ≫
        𝟙 (R₃.obj x✝)

tactic: rw [← adj₃.unit_naturality_assoc, ← R₃.map_comp, g.naturality_assoc, L₂.map_comp, assoc,
  adj₂.counit_naturality, adj₂.left_triangle_components_assoc, assoc]
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : L₂ ⟶ L₁
g : L₃ ⟶ L₂
x✝ : D
⊢ (adj₂.unit.app (R₁.obj x✝) ≫ R₂.map (f.app (R₁.obj x✝) ≫ adj₁.counit.app x✝)) ≫
      adj₃.unit.app (R₂.obj x✝) ≫ R₃.map (g.app (R₂.obj x✝) ≫ adj₂.counit.app x✝) =
    adj₃.unit.app (R₁.obj x✝) ≫ R₃.map ((g.app (R₁.obj x✝) ≫ f.app (R₁.obj x✝)) ≫ adj₁.counit.app x✝)
Theorem: MonoidAlgebra.single_algebraMap_eq_algebraMap_mul_of
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1010908
A : Type u_1
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
a : G
b : k
⊢ single a (↑(algebraMap k A) b) = ↑(algebraMap k (MonoidAlgebra A G)) b * ↑(of A G) a
Theorem: Int.emod_two_ne_one
File: Mathlib/Data/Int/Parity.lean

tactic: cases' emod_two_eq_zero_or_one n with h h <;> simp [h]
state_before: m n : ℤ
⊢ ¬n % 2 = 1 ↔ n % 2 = 0