tasksource/leandojo huggingface dataset:
Theorem: orderOf_le_of_pow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rwa [isPeriodicPt_mul_iff_pow_eq_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
hn : 0 < n
h : x ^ n = 1
⊢ IsPeriodicPt (fun x_1 => x * x_1) n 1
Theorem: Int.natAbs_le_iff_mul_self_le
File: Mathlib/Data/Int/Order/Lemmas.lean

tactic: rw [← abs_le_iff_mul_self_le, abs_eq_natAbs, abs_eq_natAbs]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a ≤ natAbs b ↔ a * a ≤ b * b

tactic: exact Int.ofNat_le.symm
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ natAbs a ≤ natAbs b ↔ ↑(natAbs a) ≤ ↑(natAbs b)
Theorem: ContinuousMultilinearMap.mkPiField_eq_zero_iff
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [← mkPiField_zero, mkPiField_eq_iff]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
z : G
⊢ ContinuousMultilinearMap.mkPiField 𝕜 ι z = 0 ↔ z = 0
Theorem: uniqueDiffWithinAt_Ioi
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp
state_before: 𝕜 : Type ?u.187149
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.187155
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.187250
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.187340
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ Set.Nonempty (interior (Ioi a))

tactic: simp
state_before: 𝕜 : Type ?u.187149
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.187155
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.187250
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.187340
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ a ∈ closure (Ioi a)
Theorem: Vector.toList_drop
File: Mathlib/Data/Vector.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α m
⊢ toList (drop n v) = List.drop n (toList v)

tactic: rfl
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝ : List α
property✝ : List.length val✝ = m
⊢ toList (drop n { val := val✝, property := property✝ }) = List.drop n (toList { val := val✝, property := property✝ })
Theorem: Nat.SOM.Poly.mulMon_denote
File: src/lean/Init/Data/Nat/SOM.lean

tactic: simp [mulMon, go]
state_before: ctx : Context
p : Poly
k : Nat
m : Mon
⊢ denote ctx (mulMon p k m) = denote ctx p * k * Mon.denote ctx m

tactic: simp!
state_before: ctx : Context
p : Poly
k : Nat
m : Mon
⊢ denote ctx [] + denote ctx p * k * Mon.denote ctx m = denote ctx p * k * Mon.denote ctx m

tactic: match p with
| [] => simp!
| (k', m') :: p =>
  simp! [go p, Nat.left_distrib, denote_insertSorted, Mon.mul_denote, Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.add_assoc]
state_before: ctx : Context
p✝ : Poly
k : Nat
m : Mon
p acc : Poly
⊢ denote ctx (mulMon.go k m p acc) = denote ctx acc + denote ctx p * k * Mon.denote ctx m

tactic: simp!
state_before: ctx : Context
p✝ : Poly
k : Nat
m : Mon
p acc : Poly
⊢ denote ctx (mulMon.go k m [] acc) = denote ctx acc + denote ctx [] * k * Mon.denote ctx m

tactic: simp! [go p, Nat.left_distrib, denote_insertSorted, Mon.mul_denote, Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm, Nat.add_assoc]
state_before: ctx : Context
p✝¹ : Poly
k : Nat
m : Mon
p✝ acc : Poly
k' : Nat
m' : Mon
p : List (Nat × Mon)
⊢ denote ctx (mulMon.go k m ((k', m') :: p) acc) = denote ctx acc + denote ctx ((k', m') :: p) * k * Mon.denote ctx m
Theorem: Nat.digitsAux_def
File: Mathlib/Data/Nat/Digits.lean

tactic: cases n
state_before: n✝ b : ℕ
h : 2 ≤ b
n : ℕ
w : 0 < n
⊢ digitsAux b h n = n % b :: digitsAux b h (n / b)

tactic: cases w
state_before: case zero
n b : ℕ
h : 2 ≤ b
w : 0 < zero
⊢ digitsAux b h zero = zero % b :: digitsAux b h (zero / b)

tactic: rw [digitsAux]
state_before: case succ
n b : ℕ
h : 2 ≤ b
n✝ : ℕ
w : 0 < succ n✝
⊢ digitsAux b h (succ n✝) = succ n✝ % b :: digitsAux b h (succ n✝ / b)
Theorem: Submonoid.LocalizationMap.lift_mk'_spec
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [f.lift_mk' hg]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
x : M
v : P
y : { x // x ∈ S }
⊢ ↑(lift f hg) (mk' f x y) = v ↔ ↑g x = ↑g ↑y * v

tactic: exact mul_inv_left hg _ _ _
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
x : M
v : P
y : { x // x ∈ S }
⊢ ↑g x * ↑(↑(IsUnit.liftRight (MonoidHom.restrict g S) hg) y)⁻¹ = v ↔ ↑g x = ↑g ↑y * v
Theorem: t2Space_iff_disjoint_nhds
File: Mathlib/Topology/Separation.lean

tactic: refine (t2Space_iff α).trans (forall₃_congr fun x y _ => ?_)
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
⊢ T2Space α ↔ ∀ (x y : α), x ≠ y → Disjoint (𝓝 x) (𝓝 y)

tactic: simp only [(nhds_basis_opens x).disjoint_iff (nhds_basis_opens y), exists_prop, ← exists_and_left,
  and_assoc, and_comm, and_left_comm]
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
x y : α
x✝ : x ≠ y
⊢ (∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v) ↔ Disjoint (𝓝 x) (𝓝 y)
Theorem: Nat.count_injective
File: Mathlib/Data/Nat/Count.lean

tactic: by_contra' h : m ≠ n
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
m n : ℕ
hm : p m
hn : p n
heq : count p m = count p n
⊢ m = n

tactic: wlog hmn : m < n
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
m n : ℕ
hm : p m
hn : p n
heq : count p m = count p n
h : m ≠ n
⊢ False

tactic: exact this hn hm heq.symm h.symm (h.lt_or_lt.resolve_left hmn)
state_before: case inr
p : ℕ → Prop
inst✝ : DecidablePred p
m n : ℕ
hm : p m
hn : p n
heq : count p m = count p n
h : m ≠ n
this : ∀ {p : ℕ → Prop} [inst : DecidablePred p] {m n : ℕ}, p m → p n → count p m = count p n → m ≠ n → m < n → False
hmn : ¬m < n
⊢ False

tactic: simpa [heq] using count_strict_mono hm hmn
state_before: p✝ : ℕ → Prop
inst✝¹ : DecidablePred p✝
p : ℕ → Prop
inst✝ : DecidablePred p
m n : ℕ
hm : p m
hn : p n
heq : count p m = count p n
h : m ≠ n
hmn : m < n
⊢ False
Theorem: MeasureTheory.lintegral_mul_left_eq_self
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: convert (lintegral_map_equiv f <| MeasurableEquiv.mulLeft g).symm
state_before: 𝕜 : Type ?u.5463
M : Type ?u.5466
α : Type ?u.5469
G : Type u_1
E : Type ?u.5475
F : Type ?u.5478
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
f : G → ℝ≥0∞
g : G
⊢ (∫⁻ (x : G), f (g * x) ∂μ) = ∫⁻ (x : G), f x ∂μ

tactic: simp [map_mul_left_eq_self μ g]
state_before: case h.e'_3.h.e'_3
𝕜 : Type ?u.5463
M : Type ?u.5466
α : Type ?u.5469
G : Type u_1
E : Type ?u.5475
F : Type ?u.5478
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
f : G → ℝ≥0∞
g : G
⊢ μ = map (↑(MeasurableEquiv.mulLeft g)) μ
Theorem: div_lt_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, div_lt_iff hc]
state_before: ι : Type ?u.30052
α : Type u_1
β : Type ?u.30058
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 < c
⊢ b / c < a ↔ b < c * a
Theorem: List.mem_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp only [mem_iff_get, Set.mem_range, get_ofFn]
state_before: α : Type u
n : ℕ
f : Fin n → α
a : α
⊢ a ∈ ofFn f ↔ a ∈ Set.range f

tactic: exact ⟨fun ⟨i, hi⟩ => ⟨Fin.cast (by simp) i, hi⟩, fun ⟨i, hi⟩ => ⟨Fin.cast (by simp) i, hi⟩⟩
state_before: α : Type u
n : ℕ
f : Fin n → α
a : α
⊢ (∃ n_1, f (↑(Fin.cast (_ : length (ofFn f) = n)) n_1) = a) ↔ ∃ y, f y = a

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin n → α
a : α
x✝ : ∃ n_1, f (↑(Fin.cast (_ : length (ofFn f) = n)) n_1) = a
i : Fin (length (ofFn f))
hi : f (↑(Fin.cast (_ : length (ofFn f) = n)) i) = a
⊢ length (ofFn f) = n

tactic: simp
state_before: α : Type u
n : ℕ
f : Fin n → α
a : α
x✝ : ∃ y, f y = a
i : Fin n
hi : f i = a
⊢ n = length (ofFn f)
Theorem: Finset.card_sdiff
File: Mathlib/Data/Finset/Card.lean

tactic: suffices card (t \ s) = card (t \ s ∪ s) - s.card by rwa [sdiff_union_of_subset h] at this
state_before: α : Type u_1
β : Type ?u.39090
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
h : s ⊆ t
⊢ card (t \ s) = card t - card s

tactic: rw [card_disjoint_union sdiff_disjoint, add_tsub_cancel_right]
state_before: α : Type u_1
β : Type ?u.39090
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
h : s ⊆ t
⊢ card (t \ s) = card (t \ s ∪ s) - card s

tactic: rwa [sdiff_union_of_subset h] at this
state_before: α : Type u_1
β : Type ?u.39090
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
h : s ⊆ t
this : card (t \ s) = card (t \ s ∪ s) - card s
⊢ card (t \ s) = card t - card s
Theorem: Int.fract_neg
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract_eq_iff]
state_before: F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ fract (-x) = 1 - fract x

tactic: constructor
state_before: F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 0 ≤ 1 - fract x ∧ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z

tactic: refine' ⟨sub_lt_self _ (lt_of_le_of_ne' (fract_nonneg x) hx), -⌊x⌋ - 1, _⟩
state_before: case right
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z

tactic: simp only [sub_sub_eq_add_sub, cast_sub, cast_neg, cast_one, sub_left_inj]
state_before: case right
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x - (1 - fract x) = ↑(-⌊x⌋ - 1)

tactic: conv in -x => rw [← floor_add_fract x]
state_before: case right
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x + fract x = -↑⌊x⌋

tactic: simp [-floor_add_fract]
state_before: case right
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -(↑⌊x⌋ + fract x) + fract x = -↑⌊x⌋

tactic: rw [le_sub_iff_add_le, zero_add]
state_before: case left
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 0 ≤ 1 - fract x

tactic: exact (fract_lt_one x).le
state_before: case left
F : Type ?u.170528
α : Type u_1
β : Type ?u.170534
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ fract x ≤ 1
Theorem: PGame.zero_equiv_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_equiv_iff, neg_zero]
state_before: x : PGame
⊢ (0 ≈ -x) ↔ (0 ≈ x)
Theorem: List.Ico.eq_nil_of_le
File: Mathlib/Data/List/Intervals.lean

tactic: simp [Ico, tsub_eq_zero_iff_le.mpr h]
state_before: n m : ℕ
h : m ≤ n
⊢ Ico n m = []
Theorem: Nat.squarefree_two
File: Mathlib/Data/Nat/Squarefree.lean

tactic: rw [squarefree_iff_nodup_factors]
state_before: ⊢ Squarefree 2

tactic: rw [Nat.factors_prime prime_two]
state_before: ⊢ List.Nodup (factors 2)

tactic: exact List.nodup_singleton 2
state_before: ⊢ List.Nodup [2]

tactic: norm_num
state_before: ⊢ 2 ≠ 0
Theorem: Irrational.ne_one
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [Nat.cast_one] using h.ne_nat 1
state_before: x : ℝ
h : Irrational x
⊢ x ≠ 1
Theorem: Tree.left_node_right_eq_self
File: Mathlib/Data/Tree.lean

tactic: trivial
state_before: α : Type u
h : nil ≠ nil
⊢ node () (left nil) (right nil) = nil
Theorem: CategoryTheory.Limits.pullback_fst_map_snd_isPullback
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: simp [condition]
state_before: C : Type ?u.598152
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f

tactic: simp [condition]
state_before: C : Type ?u.598152
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f

tactic: ext <;> simp [condition_assoc]
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (fst ≫ i₁ ≫ fst) ≫ diagonal f =
    map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
        (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
      map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
        (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)

tactic: aesop_cat
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).symm.hom ≫ snd =
    map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd) (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd)
Theorem: AddCommGroup.modEq_iff_toIcoDiv_eq_toIocDiv_add_one
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [modEq_iff_toIcoMod_add_period_eq_toIocMod hp, toIcoMod, toIocMod, ← eq_sub_iff_add_eq,
  sub_sub, sub_right_inj, ← add_one_zsmul, (zsmul_strictMono_left hp).injective.eq_iff]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1
Theorem: ENNReal.mul_iInf_of_ne
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [mul_comm] using iInf_mul_of_ne h0 h
state_before: α : Type ?u.868335
β : Type ?u.868338
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι✝ : Sort ?u.868355
f✝ g : ι✝ → ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
x : ℝ≥0∞
h0 : x ≠ 0
h : x ≠ ⊤
⊢ x * iInf f = ⨅ (i : ι), x * f i
Theorem: PowerSeries.invUnitsSub_mul_X
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: ext (_ | n)
state_before: R : Type u_1
S : Type ?u.96790
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
⊢ invUnitsSub u * X = invUnitsSub u * ↑(C R) ↑u - 1

tactic: simp
state_before: case h.zero
R : Type u_1
S : Type ?u.96790
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
⊢ ↑(coeff R Nat.zero) (invUnitsSub u * X) = ↑(coeff R Nat.zero) (invUnitsSub u * ↑(C R) ↑u - 1)

tactic: simp [n.succ_ne_zero, pow_succ]
state_before: case h.succ
R : Type u_1
S : Type ?u.96790
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
n : ℕ
⊢ ↑(coeff R (Nat.succ n)) (invUnitsSub u * X) = ↑(coeff R (Nat.succ n)) (invUnitsSub u * ↑(C R) ↑u - 1)
Theorem: padicValRat.min_le_padicValRat_add
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [min_eq_left h]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p q ≤ padicValRat p r
⊢ min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r)

tactic: exact le_padicValRat_add_of_le hqr h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p q ≤ padicValRat p r
⊢ padicValRat p q ≤ padicValRat p (q + r)

tactic: rw [min_eq_right h, add_comm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r)

tactic: exact le_padicValRat_add_of_le (by rwa [add_comm]) h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ padicValRat p r ≤ padicValRat p (r + q)

tactic: rwa [add_comm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hqr : q + r ≠ 0
h : padicValRat p r ≤ padicValRat p q
⊢ r + q ≠ 0
Theorem: Set.univ_pi_piecewise_univ
File: Mathlib/Data/Set/Function.lean

tactic: simp
state_before: α✝ : Type ?u.99082
β : Type ?u.99085
γ : Type ?u.99088
ι✝ : Sort ?u.99091
π : α✝ → Type ?u.99096
δ : α✝ → Sort ?u.99101
s✝ : Set α✝
f g : (i : α✝) → δ i
inst✝¹ : (j : α✝) → Decidable (j ∈ s✝)
ι : Type u_1
α : ι → Type u_2
s : Set ι
t : (i : ι) → Set (α i)
inst✝ : (x : ι) → Decidable (x ∈ s)
⊢ pi univ (piecewise s t fun x => univ) = pi s t
Theorem: Set.preimage_inr_image_inl
File: Mathlib/Data/Set/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.84755
ι : Sort ?u.84758
ι' : Sort ?u.84761
f : ι → α
s✝ t s : Set α
⊢ Sum.inr ⁻¹' (Sum.inl '' s) = ∅

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.84755
ι : Sort ?u.84758
ι' : Sort ?u.84761
f : ι → α
s✝ t s : Set α
x✝ : β
⊢ x✝ ∈ Sum.inr ⁻¹' (Sum.inl '' s) ↔ x✝ ∈ ∅
Theorem: Applicative.map_seq_map
File: Mathlib/Control/Applicative.lean

tactic: simp [flip, functor_norm]
state_before: F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β → γ
g : σ → β
x : F α
y : F σ
⊢ (Seq.seq (f <$> x) fun x => g <$> y) = Seq.seq ((flip (fun x x_1 => x ∘ x_1) g ∘ f) <$> x) fun x => y
Theorem: Multiset.card_eq_card_of_rel
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction h <;> simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.465908
δ : Type ?u.465911
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s : Multiset α
t : Multiset β
h : Rel r s t
⊢ ↑card s = ↑card t
Theorem: GromovHausdorff.dist_mem_candidates
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

tactic: simp_rw [candidates, Set.mem_setOf_eq, dist_comm, dist_triangle, dist_self, maxVar_bound,
  forall_const, and_true]
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ (fun p => dist p.fst p.snd) ∈ candidates X Y

tactic: exact ⟨fun x y => rfl, fun x y => rfl⟩
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
⊢ (∀ (x y : X), dist (inl x) (inl y) = dist x y) ∧ ∀ (x y : Y), dist (inr x) (inr y) = dist x y
Theorem: Finset.nonempty_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
state_before: ι : Type ?u.818
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : DenselyOrdered α
⊢ Finset.Nonempty (Ioo a b) ↔ a < b
Theorem: MeasureTheory.null_iff_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: by_cases h3μ : μ = 0
state_before: 𝕜 : Type ?u.531158
G : Type u_1
H : Type ?u.531164
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
s : Set G
hs : IsOpen s
⊢ ↑↑μ s = 0 ↔ s = ∅ ∨ μ = 0

tactic: simp [h3μ]
state_before: case pos
𝕜 : Type ?u.531158
G : Type u_1
H : Type ?u.531164
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
s : Set G
hs : IsOpen s
h3μ : μ = 0
⊢ ↑↑μ s = 0 ↔ s = ∅ ∨ μ = 0

tactic: haveI := isOpenPosMeasure_of_mulLeftInvariant_of_regular h3μ
state_before: case neg
𝕜 : Type ?u.531158
G : Type u_1
H : Type ?u.531164
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
s : Set G
hs : IsOpen s
h3μ : ¬μ = 0
⊢ ↑↑μ s = 0 ↔ s = ∅ ∨ μ = 0

tactic: simp only [h3μ, or_false_iff, hs.measure_eq_zero_iff μ]
state_before: case neg
𝕜 : Type ?u.531158
G : Type u_1
H : Type ?u.531164
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
s : Set G
hs : IsOpen s
h3μ : ¬μ = 0
this : IsOpenPosMeasure μ
⊢ ↑↑μ s = 0 ↔ s = ∅ ∨ μ = 0
Theorem: AddMonoidAlgebra.lift_unique
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: conv_lhs =>
  rw [lift_unique' F]
  simp [lift_apply]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2737055
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.2737092
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : AddMonoidAlgebra k G →ₐ[k] A
f : MonoidAlgebra k G
⊢ ↑F f = sum f fun a b => b • ↑F (single a 1)
Theorem: CategoryTheory.cokernel.π_unop
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: simp
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (cokernel.π g.unop).op = (cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (_ : A = A.unop.op)
Theorem: Basis.smul_repr
File: Mathlib/RingTheory/AlgebraTower.lean

tactic: simp [Basis.smul]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Algebra R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
ι : Type v₁
ι' : Type w₁
b : Basis ι R S
c : Basis ι' S A
x : A
ij : ι × ι'
⊢ ↑(↑(smul b c).repr x) ij = ↑(↑b.repr (↑(↑c.repr x) ij.snd)) ij.fst
Theorem: AddCommGroup.zsmul_add_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: simp [← sub_sub]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z✝ z : ℤ
⊢ a - (z • p + a) = -z • p
Theorem: List.toFinset_eq
File: Mathlib/Data/Finset/Basic.lean

tactic: rwa [Multiset.coe_nodup]
state_before: α : Type u_1
β : Type ?u.456278
γ : Type ?u.456281
inst✝ : DecidableEq α
l l' : List α
a : α
n : Nodup l
⊢ Multiset.Nodup ↑l
Theorem: Lagrange.degree_basis
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [degree_eq_natDegree (basis_ne_zero hvs hi), natDegree_basis hvs hi]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ degree (Lagrange.basis s v i) = ↑(card s - 1)