tasksource/leandojo huggingface dataset:
Theorem: Std.TransCmp.cmp_congr_right
File: Std/Classes/Order.lean

tactic: rw [← Ordering.swap_inj, symm, symm, cmp_congr_left yz]
state_before: cmp✝ : ?m.3864 → ?m.3864 → Ordering
inst✝² : TransCmp cmp✝
x✝ : Sort u_1
cmp : x✝ → x✝ → Ordering
inst✝¹ : TransCmp cmp
y z x : x✝
inst✝ : TransCmp cmp
yz : cmp y z = Ordering.eq
⊢ cmp x y = cmp x z
Theorem: induction_on_primes
File: Mathlib/RingTheory/Int/Basic.lean

tactic: apply UniqueFactorizationMonoid.induction_on_prime
state_before: P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n : ℕ
⊢ P n

tactic: exact h₀
state_before: case h₁
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n : ℕ
⊢ P 0

tactic: intro n h
state_before: case h₂
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n : ℕ
⊢ ∀ (x : ℕ), IsUnit x → P x

tactic: rw [Nat.isUnit_iff.1 h]
state_before: case h₂
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h✝ : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n✝ n : ℕ
h : IsUnit n
⊢ P n

tactic: exact h₁
state_before: case h₂
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h✝ : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n✝ n : ℕ
h : IsUnit n
⊢ P 1

tactic: intro a p _ hp ha
state_before: case h₃
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n : ℕ
⊢ ∀ (a p : ℕ), a ≠ 0 → Prime p → P a → P (p * a)

tactic: exact h p a hp.nat_prime ha
state_before: case h₃
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)
n a p : ℕ
a✝ : a ≠ 0
hp : Prime p
ha : P a
⊢ P (p * a)
Theorem: MeasureTheory.Integrable.exists_hasCompactSupport_lintegral_sub_le
File: Mathlib/MeasureTheory/Function/ContinuousMapDense.lean

tactic: simp only [← memℒp_one_iff_integrable, ← snorm_one_eq_lintegral_nnnorm] at hf ⊢
state_before: α : Type u_1
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : BorelSpace α
E : Type u_2
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : NormedSpace ℝ E
inst✝¹ : LocallyCompactSpace α
inst✝ : Measure.Regular μ
f : α → E
hf : Integrable f
ε : ℝ≥0∞
hε : ε ≠ 0
⊢ ∃ g, HasCompactSupport g ∧ (∫⁻ (x : α), ↑‖f x - g x‖₊ ∂μ) ≤ ε ∧ Continuous g ∧ Integrable g

tactic: exact hf.exists_hasCompactSupport_snorm_sub_le ENNReal.one_ne_top hε
state_before: α : Type u_1
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : BorelSpace α
E : Type u_2
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : NormedSpace ℝ E
inst✝¹ : LocallyCompactSpace α
inst✝ : Measure.Regular μ
f : α → E
ε : ℝ≥0∞
hε : ε ≠ 0
hf : Memℒp f 1
⊢ ∃ g, HasCompactSupport g ∧ snorm (fun x => f x - g x) 1 μ ≤ ε ∧ Continuous g ∧ Memℒp g 1
Theorem: MeasureTheory.VectorMeasure.le_restrict_empty
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro j _
state_before: α : Type u_1
β : Type ?u.545966
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
⊢ restrict v ∅ ≤ restrict w ∅

tactic: rw [restrict_empty, restrict_empty]
state_before: α : Type u_1
β : Type ?u.545966
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
j : Set α
a✝ : MeasurableSet j
⊢ ↑(restrict v ∅) j ≤ ↑(restrict w ∅) j
Theorem: PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← isIrreducible_iff_closure, ← zeroLocus_vanishingIdeal_eq_closure,
  isIrreducible_zeroLocus_iff_of_radical _ (isRadical_vanishingIdeal s)]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set (PrimeSpectrum R)
⊢ IsIrreducible s ↔ Ideal.IsPrime (vanishingIdeal s)
Theorem: Dfinsupp.card_Ioo
File: Mathlib/Data/Dfinsupp/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → DecidableEq (α i)
inst✝² : (i : ι) → PartialOrder (α i)
inst✝¹ : (i : ι) → Zero (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
⊢ card (Ioo f g) = ∏ i in support f ∪ support g, card (Icc (↑f i) (↑g i)) - 2
Theorem: Nat.sub_self_add
File: src/lean/Init/Data/Nat/Basic.lean

tactic: show (n + 0) - (n + m) = 0
state_before: n m : Nat
⊢ n - (n + m) = 0

tactic: rw [Nat.add_sub_add_left, Nat.zero_sub]
state_before: n m : Nat
⊢ n + 0 - (n + m) = 0
Theorem: Polynomial.IsPrimitive.dvd_primPart_iff_dvd
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: refine' ⟨fun h => h.trans (Dvd.intro_left _ q.eq_C_content_mul_primPart.symm), fun h => _⟩
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hp : IsPrimitive p
hq : q ≠ 0
⊢ p ∣ primPart q ↔ p ∣ q

tactic: rcases h with ⟨r, rfl⟩
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hp : IsPrimitive p
hq : q ≠ 0
h : p ∣ q
⊢ p ∣ primPart q

tactic: apply Dvd.intro _
state_before: case intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : IsPrimitive p
r : R[X]
hq : p * r ≠ 0
⊢ p ∣ primPart (p * r)

tactic: rw [primPart_mul hq, hp.primPart_eq]
state_before: case intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : IsPrimitive p
r : R[X]
hq : p * r ≠ 0
⊢ p * ?m.597922 = primPart (p * r)

R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : IsPrimitive p
r : R[X]
hq : p * r ≠ 0
⊢ R[X]
Theorem: EMetric.isClosed_subsets_of_isClosed
File: Mathlib/Topology/MetricSpace/Closeds.lean

tactic: refine' isClosed_of_closure_subset fun t ht x hx => _
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
⊢ IsClosed {t | ↑t ⊆ s}

tactic: have : x ∈ closure s := by
  refine' mem_closure_iff.2 fun ε εpos => _
  rcases mem_closure_iff.1 ht ε εpos with ⟨u, hu, Dtu⟩
  rcases exists_edist_lt_of_hausdorffEdist_lt hx Dtu with ⟨y, hy, Dxy⟩
  exact ⟨y, hu hy, Dxy⟩
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
⊢ x ∈ s

tactic: rwa [hs.closure_eq] at this
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
this : x ∈ closure s
⊢ x ∈ s

tactic: refine' mem_closure_iff.2 fun ε εpos => _
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
⊢ x ∈ closure s

tactic: rcases mem_closure_iff.1 ht ε εpos with ⟨u, hu, Dtu⟩
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
ε : ℝ≥0∞
εpos : ε > 0
⊢ ∃ y, y ∈ s ∧ edist x y < ε

tactic: rcases exists_edist_lt_of_hausdorffEdist_lt hx Dtu with ⟨y, hy, Dxy⟩
state_before: case intro.intro
α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
ε : ℝ≥0∞
εpos : ε > 0
u : Closeds α
hu : u ∈ {t | ↑t ⊆ s}
Dtu : edist t u < ε
⊢ ∃ y, y ∈ s ∧ edist x y < ε

tactic: exact ⟨y, hu hy, Dxy⟩
state_before: case intro.intro.intro.intro
α : Type u
inst✝ : EMetricSpace α
s : Set α
hs : IsClosed s
t : Closeds α
ht : t ∈ closure {t | ↑t ⊆ s}
x : α
hx : x ∈ ↑t
ε : ℝ≥0∞
εpos : ε > 0
u : Closeds α
hu : u ∈ {t | ↑t ⊆ s}
Dtu : edist t u < ε
y : α
hy : y ∈ ↑u
Dxy : edist x y < ε
⊢ ∃ y, y ∈ s ∧ edist x y < ε
Theorem: CategoryTheory.Under.under_left
File: Mathlib/CategoryTheory/Over.lean

tactic: simp only
state_before: T : Type u₁
inst✝ : Category T
X : T
U : Under X
⊢ U.left = { as := PUnit.unit }
Theorem: lowerSemicontinuous_iSup
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type ?u.128024
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type u_2
δ' : Type ?u.128056
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ
h : ∀ (i : ι), LowerSemicontinuous (f i)
⊢ ∀ (x : α), BddAbove (range fun i => f i x)
Theorem: Int.bitwise_and
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise and = land

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
    cond_false, cond_true, lor, Nat.ldiff', Bool.and_true, negSucc.injEq,
    Bool.and_false, Nat.land']
state_before: case h.h
m n : ℤ
⊢ bitwise and m n = land m n

tactic: . rw [Nat.bitwise'_swap, Function.swap]
  congr
  funext x y
  cases x <;> cases y <;> rfl
  rfl
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && y) m n) = land -[m+1] (ofNat n)

case h.h.negSucc.negSucc
m n : ℕ
⊢ -[Nat.bitwise' (fun x y => !(!x && !y)) m n+1] = land -[m+1] -[n+1]

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ -[Nat.bitwise' (fun x y => !(!x && !y)) m n+1] = land -[m+1] -[n+1]

tactic: rw [Nat.bitwise'_swap, Function.swap]
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => !x && y) m n) = land -[m+1] (ofNat n)

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise' (fun y x => !x && y) n m) = land -[m+1] (ofNat n)

case h.h.negSucc.ofNat
m n : ℕ
⊢ (!false && false) = false

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_a.e_f
m n : ℕ
⊢ (fun y x => !x && y) = fun a b => a && !b

case h.h.negSucc.ofNat
m n : ℕ
⊢ (!false && false) = false

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!y && x) = (x && !y)

case h.h.negSucc.ofNat
m n : ℕ
⊢ (!false && false) = false

tactic: rfl
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ (!false && false) = false

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ -[Nat.bitwise' (fun x y => !(!x && !y)) m n+1] = land -[m+1] -[n+1]

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => !(!x && !y)) = or

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x && !y)) = (x || y)
Theorem: Filter.map_comap_of_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [map_comap, inf_eq_left.2 (le_principal_iff.2 hf)]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.257261
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hf : range m ∈ f
⊢ map m (comap m f) = f
Theorem: Int.natAbs_div
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.div_neg, natAbs_neg, natAbs_neg]
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div (↑w✝¹) (-↑w✝)) = Nat.div (natAbs ↑w✝¹) (natAbs (-↑w✝))

tactic: rfl
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)

tactic: rw [Int.neg_div, natAbs_neg, natAbs_neg]
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div (-↑w✝¹) ↑w✝) = Nat.div (natAbs (-↑w✝¹)) (natAbs ↑w✝)

tactic: rfl
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)

tactic: rw [Int.neg_div_neg, natAbs_neg, natAbs_neg]
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div (-↑w✝¹) (-↑w✝)) = Nat.div (natAbs (-↑w✝¹)) (natAbs (-↑w✝))

tactic: rfl
state_before: a b : Int
w✝¹ w✝ : Nat
⊢ natAbs (div ↑w✝¹ ↑w✝) = Nat.div (natAbs ↑w✝¹) (natAbs ↑w✝)
Theorem: SimpleGraph.adjMatrix_mulVec_const_apply_of_regular
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [hd v]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.66478
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype V
inst✝ : Semiring α
d : ℕ
a : α
hd : IsRegularOfDegree G d
v : V
⊢ mulVec (adjMatrix α G) (Function.const V a) v = ↑d * a
Theorem: List.pairwise_pair
File: Mathlib/Data/List/Pairwise.lean

tactic: simp only [pairwise_cons, mem_singleton, forall_eq, forall_prop_of_false (not_mem_nil _),
  forall_true_iff, Pairwise.nil, and_true_iff]
state_before: α : Type u_1
β : Type ?u.9008
R S T : α → α → Prop
a✝ : α
l : List α
a b : α
⊢ Pairwise R [a, b] ↔ R a b
Theorem: Zsqrtd.muld_val
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp [ext]
state_before: d x y : ℤ
⊢ sqrtd * { re := x, im := y } = { re := d * y, im := x }
Theorem: Filter.comap_fst_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: cases isEmpty_or_nonempty β
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.265787
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β

tactic: rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type ?u.265787
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : IsEmpty β
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β

tactic: simp [*]
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type ?u.265787
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : IsEmpty β
⊢ ¬NeBot ⊥ ↔ ¬(NeBot f ∧ Nonempty β)

tactic: simp [comap_neBot_iff_frequently, *]
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type ?u.265787
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
h✝ : Nonempty β
⊢ NeBot (comap Prod.fst f) ↔ NeBot f ∧ Nonempty β
Theorem: Nat.totient_eq_prod_factorization
File: Mathlib/Data/Nat/Totient.lean

tactic: rw [multiplicative_factorization φ (@totient_mul) totient_one hn]
state_before: n : ℕ
hn : n ≠ 0
⊢ φ n = Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)

tactic: apply Finsupp.prod_congr  _
state_before: n : ℕ
hn : n ≠ 0
⊢ (Finsupp.prod (factorization n) fun p k => φ (p ^ k)) =
    Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)

tactic: intro p hp
state_before: n : ℕ
hn : n ≠ 0
⊢ ∀ (x : ℕ), x ∈ (factorization n).support → φ (x ^ ↑(factorization n) x) = x ^ (↑(factorization n) x - 1) * (x - 1)

tactic: have h := zero_lt_iff.mpr (Finsupp.mem_support_iff.mp hp)
state_before: n : ℕ
hn : n ≠ 0
p : ℕ
hp : p ∈ (factorization n).support
⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)

tactic: rw [totient_prime_pow (prime_of_mem_factorization hp) h]
state_before: n : ℕ
hn : n ≠ 0
p : ℕ
hp : p ∈ (factorization n).support
h : 0 < ↑(factorization n) p
⊢ φ (p ^ ↑(factorization n) p) = p ^ (↑(factorization n) p - 1) * (p - 1)
Theorem: toIocDiv_add_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine' toIocDiv_eq_of_sub_zsmul_mem_Ioc _ _
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocDiv hp (a + m • p) b = toIocDiv hp a b - m

tactic: rw [sub_smul, ← sub_add, add_right_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b - (toIocDiv hp a b - m) • p ∈ Set.Ioc (a + m • p) (a + m • p + p)

tactic: simpa using sub_toIocDiv_zsmul_mem_Ioc hp a b
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b - toIocDiv hp a b • p + m • p ∈ Set.Ioc (a + m • p) (a + p + m • p)
Theorem: Polynomial.map_dvd_map'
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [H, Polynomial.map_zero, zero_dvd_iff, zero_dvd_iff, map_eq_zero]
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]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : x = 0
⊢ map f x ∣ map f y ↔ x ∣ y

tactic: rw [← normalize_dvd_iff, ← @normalize_dvd_iff R[X], normalize_apply, normalize_apply,
  coe_normUnit_of_ne_zero H, coe_normUnit_of_ne_zero (mt (map_eq_zero f).1 H),
  leadingCoeff_map, ← map_inv₀ f, ← map_C, ← Polynomial.map_mul,
  map_dvd_map _ f.injective (monic_mul_leadingCoeff_inv 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]
inst✝ : Field k
f : R →+* k
x y : R[X]
H : ¬x = 0
⊢ map f x ∣ map f y ↔ x ∣ y
Theorem: Polynomial.mem_roots_map
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [mem_roots (map_ne_zero hp), IsRoot, Polynomial.eval_map]
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]
inst✝¹ : CommRing k
inst✝ : IsDomain k
f : R →+* k
x : k
hp : p ≠ 0
⊢ x ∈ roots (map f p) ↔ eval₂ f x p = 0
Theorem: map_restrict_ae_le_map_indicator_ae
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: intro t
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
⊢ Filter.map f (ae (Measure.restrict μ s)) ≤ Filter.map (indicator s f) (ae μ)

tactic: by_cases ht : (0 : β) ∈ t
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
t : Set β
⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))

tactic: rw [mem_map_indicator_ae_iff_of_zero_nmem ht, mem_map_restrict_ae_iff hs]
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
t : Set β
ht : ¬0 ∈ t
⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))

tactic: exact fun h => measure_mono_null ((Set.inter_subset_left _ _).trans (Set.subset_union_left _ _)) h
state_before: case neg
α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
t : Set β
ht : ¬0 ∈ t
⊢ ↑↑μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0 → ↑↑μ ((f ⁻¹' t)ᶜ ∩ s) = 0

tactic: rw [mem_map_indicator_ae_iff_mem_map_restrict_ae_of_zero_mem ht hs]
state_before: case pos
α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
t : Set β
ht : 0 ∈ t
⊢ t ∈ Filter.map (indicator s f) (ae μ) → t ∈ Filter.map f (ae (Measure.restrict μ s))

tactic: exact id
state_before: case pos
α : Type u_2
β : Type u_1
γ : Type ?u.4605823
δ : Type ?u.4605826
ι : Type ?u.4605829
R : Type ?u.4605832
R' : Type ?u.4605835
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t✝ : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
t : Set β
ht : 0 ∈ t
⊢ t ∈ Filter.map f (ae (Measure.restrict μ s)) → t ∈ Filter.map f (ae (Measure.restrict μ s))
Theorem: Polynomial.support_monomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← ofFinsupp_single, support]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
H : a ≠ 0
⊢ support (↑(monomial n) a) = {n}

tactic: exact Finsupp.support_single_ne_zero _ H
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
H : a ≠ 0
⊢ (match { toFinsupp := Finsupp.single n a } with
    | { toFinsupp := p } => p.support) =
    {n}
Theorem: Stream'.WSeq.dropn_tail
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [add_comm]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ drop (tail s) n = drop s (n + 1)

tactic: symm
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ drop (tail s) n = drop s (1 + n)

tactic: apply dropn_add
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ drop s (1 + n) = drop (tail s) n
Theorem: Real.cos_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [cos_add]
state_before: x : ℝ
⊢ cos (x + π / 2) = -sin x
Theorem: HahnSeries.SummableFamily.hsum_sub
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [← lsum_apply, LinearMap.map_sub, lsum_apply, lsum_apply]
state_before: Γ : Type u_2
R✝ : Type ?u.2750260
inst✝² : OrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R✝
α : Type u_3
R : Type u_1
inst✝ : Ring R
s t : SummableFamily Γ R α
⊢ hsum (s - t) = hsum s - hsum t
Theorem: LieAlgebra.subsingleton_of_semisimple_lie_abelian
File: Mathlib/Algebra/Lie/Semisimple.lean

tactic: rw [isLieAbelian_iff_center_eq_top R L, center_eq_bot_of_semisimple] at h
state_before: R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : IsSemisimple R L
h : IsLieAbelian L
⊢ Subsingleton L

tactic: exact (LieSubmodule.subsingleton_iff R L L).mp (subsingleton_of_bot_eq_top h)
state_before: R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
inst✝ : IsSemisimple R L
h : ⊥ = ⊤
⊢ Subsingleton L
Theorem: Polynomial.eval₂_add
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [eval₂_eq_sum]
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 : R →+* S
x : S
⊢ eval₂ f x (p + q) = eval₂ f x p + eval₂ f x q

tactic: apply sum_add_index <;> simp [add_mul]
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 : R →+* S
x : S
⊢ (sum (p + q) fun e a => ↑f a * x ^ e) = (sum p fun e a => ↑f a * x ^ e) + sum q fun e a => ↑f a * x ^ e
Theorem: Nat.pow_sub_lt_descFactorial'
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [descFactorial_succ, pow_succ, pow_one, descFactorial_one]
state_before: n : ℕ
h : 0 + 2 ≤ n
⊢ (n - (0 + 1)) ^ (0 + 2) < descFactorial n (0 + 2)

tactic: exact
  Nat.mul_lt_mul_of_pos_left (tsub_lt_self (lt_of_lt_of_le zero_lt_two h) zero_lt_one)
    (tsub_pos_of_lt h)
state_before: n : ℕ
h : 0 + 2 ≤ n
⊢ (n - (0 + 1)) * (n - (0 + 1)) < (n - 1) * n

tactic: rw [descFactorial_succ, pow_succ, mul_comm]
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) ^ (k + 1 + 2) < descFactorial n (k + 1 + 2)

tactic: apply Nat.mul_lt_mul_of_pos_left
state_before: n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) * (n - (k + 1 + 1)) ^ (k + 2) < (n - (k + 2)) * descFactorial n (k + 2)

tactic: refine' ((Nat.pow_le_pow_of_le_left (tsub_le_tsub_right (le_succ n) _) _).trans_lt _)
state_before: case h
n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)

tactic: rw [succ_sub_succ]
state_before: case h
n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (succ n - (k + 1 + 1)) ^ (k + 2) < descFactorial n (k + 2)

tactic: exact pow_sub_lt_descFactorial' ((le_succ _).trans h)
state_before: case h
n k : ℕ
h : k + 1 + 2 ≤ n
⊢ (n - (k + 1)) ^ (k + 2) < descFactorial n (k + 2)

tactic: apply tsub_pos_of_lt
state_before: case hk
n k : ℕ
h : k + 1 + 2 ≤ n
⊢ n - (k + 1 + 1) > 0

tactic: apply h
state_before: case hk.h
n k : ℕ
h : k + 1 + 2 ≤ n
⊢ k + 1 + 1 < n