tasksource/leandojo huggingface dataset:
Theorem: AdjoinRoot.mk_leftInverse
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: intro f
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : Monic g
⊢ Function.LeftInverse ↑(mk g) ↑(modByMonicHom hg)

tactic: induction f using AdjoinRoot.induction_on
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : Monic g
f : AdjoinRoot g
⊢ ↑(mk g) (↑(modByMonicHom hg) f) = f

tactic: rw [modByMonicHom_mk hg, mk_eq_mk, modByMonic_eq_sub_mul_div _ hg, sub_sub_cancel_left,
  dvd_neg]
state_before: case ih
R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : Monic g
p✝ : R[X]
⊢ ↑(mk g) (↑(modByMonicHom hg) (↑(mk g) p✝)) = ↑(mk g) p✝

tactic: apply dvd_mul_right
state_before: case ih
R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
g : R[X]
hg : Monic g
p✝ : R[X]
⊢ g ∣ g * (p✝ /ₘ g)
Theorem: Rat.mkRat_one
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [Rat.mkRat_eq, Rat.divInt_one]
state_before: a b c : ℚ
n : ℤ
⊢ mkRat n 1 = ↑n
Theorem: RingQuot.Rel.sub_right
File: Mathlib/Algebra/RingQuot.lean

tactic: simp only [sub_eq_add_neg, h.neg.add_right]
state_before: R✝ : Type u₁
inst✝⁴ : Semiring R✝
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
R : Type u₁
inst✝ : Ring R
r : R → R → Prop
a b c : R
h : Rel r b c
⊢ Rel r (a - b) (a - c)
Theorem: Fin.coe_cycleRange_of_lt
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: rw [coe_cycleRange_of_le h.le, if_neg h.ne]
state_before: n : ℕ
i j : Fin (Nat.succ n)
h : j < i
⊢ ↑(↑(cycleRange i) j) = ↑j + 1
Theorem: LinearMap.IsRefl.ker_flip_eq_bot
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: refine' ker_eq_bot'.mpr fun _ hx ↦ ker_eq_bot'.mp h _ _
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type ?u.117040
R₃ : Type ?u.117043
M : Type ?u.117046
M₁ : Type u_3
M₂ : Type ?u.117052
Mₗ₁ : Type ?u.117055
Mₗ₁' : Type ?u.117058
Mₗ₂ : Type ?u.117061
Mₗ₂' : Type ?u.117064
K : Type ?u.117067
K₁ : Type ?u.117070
K₂ : Type ?u.117073
V : Type ?u.117076
V₁ : Type ?u.117079
V₂ : Type ?u.117082
n : Type ?u.117085
inst✝³ : CommSemiring R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H✝ H : IsRefl B
h : ker B = ⊥
⊢ ker (flip B) = ⊥

tactic: ext
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type ?u.117040
R₃ : Type ?u.117043
M : Type ?u.117046
M₁ : Type u_3
M₂ : Type ?u.117052
Mₗ₁ : Type ?u.117055
Mₗ₁' : Type ?u.117058
Mₗ₂ : Type ?u.117061
Mₗ₂' : Type ?u.117064
K : Type ?u.117067
K₁ : Type ?u.117070
K₂ : Type ?u.117073
V : Type ?u.117076
V₁ : Type ?u.117079
V₂ : Type ?u.117082
n : Type ?u.117085
inst✝³ : CommSemiring R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H✝ H : IsRefl B
h : ker B = ⊥
x✝ : M₁
hx : ↑(flip B) x✝ = 0
⊢ ↑B x✝ = 0

tactic: exact H _ _ (LinearMap.congr_fun hx _)
state_before: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type ?u.117040
R₃ : Type ?u.117043
M : Type ?u.117046
M₁ : Type u_3
M₂ : Type ?u.117052
Mₗ₁ : Type ?u.117055
Mₗ₁' : Type ?u.117058
Mₗ₂ : Type ?u.117061
Mₗ₂' : Type ?u.117064
K : Type ?u.117067
K₁ : Type ?u.117070
K₂ : Type ?u.117073
V : Type ?u.117076
V₁ : Type ?u.117079
V₂ : Type ?u.117082
n : Type ?u.117085
inst✝³ : CommSemiring R
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] R
H✝ H : IsRefl B
h : ker B = ⊥
x✝¹ : M₁
hx : ↑(flip B) x✝¹ = 0
x✝ : M₁
⊢ ↑(↑B x✝¹) x✝ = ↑0 x✝
Theorem: HasStrictFDerivAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert (@hasStrictFDerivAt_cpow ((fun x => (f x, g x)) x) h0).comp x (hf.prod hg)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
f' g' : E →L[ℂ] ℂ
x : E
s : Set E
c : ℂ
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
h0 : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasStrictFDerivAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') x
Theorem: MeasureTheory.exists_measurable_superset_forall_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa only [← measure_eq_trim] using
  OuterMeasure.exists_measurable_superset_forall_eq_trim (fun i => (μ i).toOuterMeasure) s
state_before: α : Type u_2
β : Type ?u.14786
γ : Type ?u.14789
δ : Type ?u.14792
ι✝ : Type ?u.14795
inst✝¹ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), ↑↑(μ i) t = ↑↑(μ i) s
Theorem: MvPowerSeries.coeff_zero_mul_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: have : ¬single s 1 ≤ 0 := fun h => by simpa using h s
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
⊢ ↑(coeff R 0) (φ * X s) = 0

tactic: simp only [X, coeff_mul_monomial, if_neg this]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
this : ¬single s 1 ≤ 0
⊢ ↑(coeff R 0) (φ * X s) = 0

tactic: simpa using h s
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
h : single s 1 ≤ 0
⊢ False
Theorem: zorn_nonempty_Ici₀
File: Mathlib/Order/Zorn.lean

tactic: simpa using ih
state_before: α : Type u_1
β : Type ?u.6442
r : α → α → Prop
c : Set α
inst✝ : Preorder α
a : α
ih :
  ∀ (c : Set α),
    c ⊆ Ici a → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, a ≤ ub ∧ ∀ (z : α), z ∈ c → z ≤ ub
x : α
hax : a ≤ x
⊢ ∀ (c : Set α),
    c ⊆ Ici a → IsChain (fun x x_1 => x ≤ x_1) c → ∀ (y : α), y ∈ c → ∃ ub, ub ∈ Ici a ∧ ∀ (z : α), z ∈ c → z ≤ ub
Theorem: Multiset.prod_pair
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [insert_eq_cons, prod_cons, prod_singleton]
state_before: ι : Type ?u.12245
α : Type u_1
β : Type ?u.12251
γ : Type ?u.12254
inst✝ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
a b : α
⊢ prod {a, b} = a * b
Theorem: Std.RBNode.Stream.foldl_eq_foldl_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t generalizing init <;> simp [-List.foldl] <;> simp [*, RBNode.foldl_eq_foldl_toList]
state_before: α : Type u_1
α✝ : Type u_2
f : α✝ → α → α✝
init : α✝
t : RBNode.Stream α
⊢ foldl f init t = List.foldl f init (toList t)
Theorem: Sylow.prime_dvd_card_quotient_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← card_eq_card_quotient_mul_card_subgroup H, hH, hs, pow_succ', mul_assoc, mul_comm p]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
hdvd : p ^ (n + 1) ∣ Fintype.card G
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
s : ℕ
hs : Fintype.card G = s * p ^ (n + 1)
⊢ Fintype.card (G ⧸ H) * Fintype.card { x // x ∈ H } = s * p * Fintype.card { x // x ∈ H }

tactic: rwa [Nat.mod_eq_zero_of_dvd (dvd_mul_left _ _), eq_comm] at hm
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
hdvd : p ^ (n + 1) ∣ Fintype.card G
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
s : ℕ
hs : Fintype.card G = s * p ^ (n + 1)
hcard : Fintype.card (G ⧸ H) = s * p
hm : s * p % p = Fintype.card ({ x // x ∈ normalizer H } ⧸ Subgroup.comap (Subgroup.subtype (normalizer H)) H) % p
⊢ Fintype.card ({ x // x ∈ normalizer H } ⧸ Subgroup.comap (Subgroup.subtype (normalizer H)) H) % p = 0
Theorem: div_sub'
File: Mathlib/Algebra/Field/Basic.lean

tactic: simpa using div_sub_div a b hc one_ne_zero
state_before: α : Type ?u.57003
β : Type ?u.57006
K : Type u_1
inst✝ : Field K
a b c : K
hc : c ≠ 0
⊢ a / c - b = (a - c * b) / c
Theorem: Finset.weightedVSubVSubWeights_self
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [weightedVSubVSubWeights]
state_before: k : Type u_2
V : Type ?u.418752
P : Type ?u.418755
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.419411
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i : ι
⊢ weightedVSubVSubWeights k i i = 0
Theorem: CategoryTheory.NatIso.inv_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F✝ G✝ : C ⥤ D
α : F✝ ≅ G✝
F G : C ⥤ D
e : F ≅ G
X : C
⊢ inv (e.inv.app X) = e.hom.app X
Theorem: derivedSeries_normal
File: Mathlib/GroupTheory/Solvable.lean

tactic: induction' n with n ih
state_before: G : Type u_1
G' : Type ?u.4100
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
n : ℕ
⊢ Normal (derivedSeries G n)

tactic: exact (⊤ : Subgroup G).normal_of_characteristic
state_before: case zero
G : Type u_1
G' : Type ?u.4100
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
⊢ Normal (derivedSeries G Nat.zero)

tactic: exact @Subgroup.commutator_normal G _ (derivedSeries G n) (derivedSeries G n) ih ih
state_before: case succ
G : Type u_1
G' : Type ?u.4100
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
n : ℕ
ih : Normal (derivedSeries G n)
⊢ Normal (derivedSeries G (Nat.succ n))
Theorem: Ordinal.succ_one
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: unfold instOfNat OfNat.ofNat
state_before: α : Type ?u.178408
β : Type ?u.178411
γ : Type ?u.178414
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ succ 1 = 2

tactic: simpa using by rfl
state_before: α : Type ?u.178408
β : Type ?u.178411
γ : Type ?u.178414
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ succ One.toOfNat1.1 = { ofNat := ↑2 }.1

tactic: rfl
state_before: α : Type ?u.178408
β : Type ?u.178411
γ : Type ?u.178414
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ One.toOfNat1.1 = 1
Theorem: CategoryTheory.Monad.algebra_iso_of_iso
File: Mathlib/CategoryTheory/Monad/Algebra.lean

tactic: rw [IsIso.eq_comp_inv f.f, Category.assoc, ← f.h]
state_before: C : Type u₁
inst✝¹ : Category C
T : Monad C
A B : Algebra T
f : A ⟶ B
inst✝ : IsIso f.f
⊢ T.map (inv f.f) ≫ A.a = B.a ≫ inv f.f

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
T : Monad C
A B : Algebra T
f : A ⟶ B
inst✝ : IsIso f.f
⊢ T.map (inv f.f) ≫ T.map f.f ≫ B.a = B.a

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category C
T : Monad C
A B : Algebra T
f : A ⟶ B
inst✝ : IsIso f.f
⊢ f ≫ Algebra.Hom.mk (inv f.f) = 𝟙 A ∧ Algebra.Hom.mk (inv f.f) ≫ f = 𝟙 B
Theorem: Units.val_eq_one
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← Units.val_one, eq_iff]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u a : αˣ
⊢ ↑a = 1 ↔ a = 1
Theorem: Multiset.mem_of_mem_nsmul
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type ?u.46161
γ : Type ?u.46164
a : α
s : Multiset α
n : ℕ
h : a ∈ n • s
⊢ a ∈ s

tactic: rw [zero_nsmul] at h
state_before: case zero
α : Type u_1
β : Type ?u.46161
γ : Type ?u.46164
a : α
s : Multiset α
n : ℕ
h✝ : a ∈ n • s
h : a ∈ zero • s
⊢ a ∈ s

tactic: exact absurd h (not_mem_zero _)
state_before: case zero
α : Type u_1
β : Type ?u.46161
γ : Type ?u.46164
a : α
s : Multiset α
n : ℕ
h✝ : a ∈ n • s
h : a ∈ 0
⊢ a ∈ s

tactic: rw [succ_nsmul, mem_add] at h
state_before: case succ
α : Type u_1
β : Type ?u.46161
γ : Type ?u.46164
a : α
s : Multiset α
n✝ : ℕ
h✝ : a ∈ n✝ • s
n : ℕ
ih : a ∈ n • s → a ∈ s
h : a ∈ succ n • s
⊢ a ∈ s

tactic: exact h.elim id ih
state_before: case succ
α : Type u_1
β : Type ?u.46161
γ : Type ?u.46164
a : α
s : Multiset α
n✝ : ℕ
h✝ : a ∈ n✝ • s
n : ℕ
ih : a ∈ n • s → a ∈ s
h : a ∈ s ∨ a ∈ n • s
⊢ a ∈ s
Theorem: Wcovby.le_and_le_iff
File: Mathlib/Order/Cover.lean

tactic: refine' ⟨fun h2 => h.eq_or_eq h2.1 h2.2, _⟩
state_before: α : Type u_1
β : Type ?u.16828
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
⊢ a ≤ c ∧ c ≤ b ↔ c = a ∨ c = b

tactic: rintro (rfl | rfl)
state_before: α : Type u_1
β : Type ?u.16828
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
⊢ c = a ∨ c = b → a ≤ c ∧ c ≤ b

tactic: exacts [⟨le_rfl, h.le⟩, ⟨h.le, le_rfl⟩]
state_before: case inl
α : Type u_1
β : Type ?u.16828
inst✝ : PartialOrder α
b c : α
h : c ⩿ b
⊢ c ≤ c ∧ c ≤ b

case inr
α : Type u_1
β : Type ?u.16828
inst✝ : PartialOrder α
a c : α
h : a ⩿ c
⊢ a ≤ c ∧ c ≤ c
Theorem: IsCoprime.prod_left
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: rw [Finset.prod_insert hbt]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t✝ : Finset I
b : I
t : Finset I
hbt : ¬b ∈ t
ih : (∀ (i : I), i ∈ t → IsCoprime (s i) x) → IsCoprime (∏ i in t, s i) x
H : ∀ (i : I), i ∈ insert b t → IsCoprime (s i) x
⊢ IsCoprime (∏ i in insert b t, s i) x

tactic: rw [Finset.forall_mem_insert] at H
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t✝ : Finset I
b : I
t : Finset I
hbt : ¬b ∈ t
ih : (∀ (i : I), i ∈ t → IsCoprime (s i) x) → IsCoprime (∏ i in t, s i) x
H : ∀ (i : I), i ∈ insert b t → IsCoprime (s i) x
⊢ IsCoprime (s b * ∏ x in t, s x) x

tactic: exact H.1.mul_left (ih H.2)
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t✝ : Finset I
b : I
t : Finset I
hbt : ¬b ∈ t
ih : (∀ (i : I), i ∈ t → IsCoprime (s i) x) → IsCoprime (∏ i in t, s i) x
H : IsCoprime (s b) x ∧ ∀ (x_1 : I), x_1 ∈ t → IsCoprime (s x_1) x
⊢ IsCoprime (s b * ∏ x in t, s x) x
Theorem: ENNReal.Tendsto.mul_const
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa only [mul_comm] using ENNReal.Tendsto.const_mul hm ha
state_before: α : Type u_1
β : Type ?u.98424
γ : Type ?u.98427
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ ⊤
⊢ Tendsto (fun x => m x * b) f (𝓝 (a * b))
Theorem: Polynomial.coeff_sub
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
p q : R[X]
n : ℕ
⊢ coeff (p - q) n = coeff p n - coeff q n

tactic: rcases q with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
q : R[X]
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := toFinsupp✝ } - q) n = coeff { toFinsupp := toFinsupp✝ } n - coeff q n

tactic: rw [← ofFinsupp_sub, coeff, coeff, coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := toFinsupp✝¹ } - { toFinsupp := toFinsupp✝ }) n =
    coeff { toFinsupp := toFinsupp✝¹ } n - coeff { toFinsupp := toFinsupp✝ } n

tactic: apply Finsupp.sub_apply
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ - toFinsupp✝ } with
      | { toFinsupp := p } => ↑p)
      n =
    (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ } with
        | { toFinsupp := p } => ↑p)
        n -
      (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝ } with
        | { toFinsupp := p } => ↑p)
        n
Theorem: disjoint_compl_right_iff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← le_compl_iff_disjoint_right, compl_compl]
state_before: α : Type u
β : Type ?u.60077
w x y z : α
inst✝ : BooleanAlgebra α
⊢ Disjoint x (yᶜ) ↔ x ≤ y
Theorem: Cycle.card_toMultiset
File: Mathlib/Data/List/Cycle.lean

tactic: simp
state_before: α : Type u_1
s : Cycle α
⊢ ∀ (a : List α), ↑Multiset.card (toMultiset (Quotient.mk'' a)) = length (Quotient.mk'' a)
Theorem: StarConvex.mem_smul
File: Mathlib/Analysis/Convex/Star.lean

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ (zero_lt_one.trans_le ht).ne']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.156386
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
hs : StarConvex 𝕜 0 s
hx : x ∈ s
t : 𝕜
ht : 1 ≤ t
⊢ x ∈ t • s

tactic: exact hs.smul_mem hx (by positivity) (inv_le_one ht)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.156386
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
hs : StarConvex 𝕜 0 s
hx : x ∈ s
t : 𝕜
ht : 1 ≤ t
⊢ t⁻¹ • x ∈ s

tactic: positivity
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.156386
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x : E
s : Set E
hs : StarConvex 𝕜 0 s
hx : x ∈ s
t : 𝕜
ht : 1 ≤ t
⊢ 0 ≤ t⁻¹
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_neg_add_self_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: apply shift_shiftFunctorCompIsoId_inv_app
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n : A
X : C
⊢ (shiftFunctor C (-n)).map ((shiftFunctorCompIsoId C (-n) n (_ : -n + n = 0)).inv.app X) =
    (shiftFunctorCompIsoId C n (-n) (_ : n + -n = 0)).inv.app ((shiftFunctor C (-n)).obj X)
Theorem: Rel.card_interedges_finpartition_right
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: classical
simp_rw [← P.biUnion_parts, interedges_biUnion_right, id]
rw [card_biUnion]
exact fun x hx y hy h ↦ interedges_disjoint_right r _ (P.disjoint hx hy h)
state_before: 𝕜 : Type ?u.24112
ι : Type ?u.24115
κ : Type ?u.24118
α : Type u_2
β : Type u_1
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq β
s : Finset α
P : Finpartition t
⊢ card (interedges r s t) = ∑ b in P.parts, card (interedges r s b)

tactic: simp_rw [← P.biUnion_parts, interedges_biUnion_right, id]
state_before: 𝕜 : Type ?u.24112
ι : Type ?u.24115
κ : Type ?u.24118
α : Type u_2
β : Type u_1
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq β
s : Finset α
P : Finpartition t
⊢ card (interedges r s t) = ∑ b in P.parts, card (interedges r s b)

tactic: rw [card_biUnion]
state_before: 𝕜 : Type ?u.24112
ι : Type ?u.24115
κ : Type ?u.24118
α : Type u_2
β : Type u_1
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq β
s : Finset α
P : Finpartition t
⊢ card (Finset.biUnion P.parts fun b => interedges r s b) = ∑ b in P.parts, card (interedges r s b)

tactic: exact fun x hx y hy h ↦ interedges_disjoint_right r _ (P.disjoint hx hy h)
state_before: 𝕜 : Type ?u.24112
ι : Type ?u.24115
κ : Type ?u.24118
α : Type u_2
β : Type u_1
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq β
s : Finset α
P : Finpartition t
⊢ ∀ (x : Finset β), x ∈ P.parts → ∀ (y : Finset β), y ∈ P.parts → x ≠ y → Disjoint (interedges r s x) (interedges r s y)
Theorem: exp_neg_integrableOn_Ioi
File: Mathlib/MeasureTheory/Integral/ExpDecay.lean

tactic: have : Tendsto (fun x => -exp (-b * x) / b) atTop (𝓝 (-0 / b)) := by
  refine' Tendsto.div_const (Tendsto.neg _) _
  exact tendsto_exp_atBot.comp (tendsto_id.neg_const_mul_atTop (Right.neg_neg_iff.2 h))
state_before: a b : ℝ
h : 0 < b
⊢ IntegrableOn (fun x => exp (-b * x)) (Ioi a)

tactic: refine' integrableOn_Ioi_deriv_of_nonneg' (fun x _ => _) (fun x _ => (exp_pos _).le) this
state_before: a b : ℝ
h : 0 < b
this : Tendsto (fun x => -exp (-b * x) / b) atTop (𝓝 (-0 / b))
⊢ IntegrableOn (fun x => exp (-b * x)) (Ioi a)

tactic: simpa [h.ne'] using ((hasDerivAt_id x).const_mul b).neg.exp.neg.div_const b
state_before: a b : ℝ
h : 0 < b
this : Tendsto (fun x => -exp (-b * x) / b) atTop (𝓝 (-0 / b))
x : ℝ
x✝ : x ∈ Ici a
⊢ HasDerivAt (fun x => -exp (-b * x) / b) (exp (-b * x)) x

tactic: refine' Tendsto.div_const (Tendsto.neg _) _
state_before: a b : ℝ
h : 0 < b
⊢ Tendsto (fun x => -exp (-b * x) / b) atTop (𝓝 (-0 / b))

tactic: exact tendsto_exp_atBot.comp (tendsto_id.neg_const_mul_atTop (Right.neg_neg_iff.2 h))
state_before: a b : ℝ
h : 0 < b
⊢ Tendsto (fun x => exp (-b * x)) atTop (𝓝 0)
Theorem: CategoryTheory.Limits.CoconeMorphism.ext
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: cases f
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cocone F
f g : c ⟶ c'
w : f.Hom = g.Hom
⊢ f = g

tactic: cases g
state_before: case mk
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cocone F
g : c ⟶ c'
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), c.ι.app j ≫ Hom✝ = c'.ι.app j
w : (mk Hom✝).Hom = g.Hom
⊢ mk Hom✝ = g

tactic: congr
state_before: case mk.mk
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c c' : Cocone F
Hom✝¹ : c.pt ⟶ c'.pt
w✝¹ : ∀ (j : J), c.ι.app j ≫ Hom✝¹ = c'.ι.app j
Hom✝ : c.pt ⟶ c'.pt
w✝ : ∀ (j : J), c.ι.app j ≫ Hom✝ = c'.ι.app j
w : (mk Hom✝¹).Hom = (mk Hom✝).Hom
⊢ mk Hom✝¹ = mk Hom✝
Theorem: WType.elim_injective
File: Mathlib/Data/W/Basic.lean

tactic: obtain ⟨rfl, h⟩ := Sigma.mk.inj_iff.mp (fγ_injective h)
state_before: α : Type u_2
β : α → Type u_3
γ : Type u_1
fγ : (a : α) × (β a → γ) → γ
fγ_injective : Function.Injective fγ
a₁ : α
f₁ : β a₁ → WType fun a => β a
a₂ : α
f₂ : β a₂ → WType fun a => β a
h : elim γ fγ (mk a₁ f₁) = elim γ fγ (mk a₂ f₂)
⊢ mk a₁ f₁ = mk a₂ f₂

tactic: congr with x
state_before: case intro
α : Type u_2
β : α → Type u_3
γ : Type u_1
fγ : (a : α) × (β a → γ) → γ
fγ_injective : Function.Injective fγ
a₁ : α
f₁ f₂ : β a₁ → WType fun a => β a
h✝ : elim γ fγ (mk a₁ f₁) = elim γ fγ (mk a₁ f₂)
h : HEq (fun b => elim γ fγ (f₁ b)) fun b => elim γ fγ (f₂ b)
⊢ mk a₁ f₁ = mk a₁ f₂

tactic: exact elim_injective γ fγ fγ_injective (congr_fun (eq_of_heq h) x : _)
state_before: case intro.e_f.h
α : Type u_2
β : α → Type u_3
γ : Type u_1
fγ : (a : α) × (β a → γ) → γ
fγ_injective : Function.Injective fγ
a₁ : α
f₁ f₂ : β a₁ → WType fun a => β a
h✝ : elim γ fγ (mk a₁ f₁) = elim γ fγ (mk a₁ f₂)
h : HEq (fun b => elim γ fγ (f₁ b)) fun b => elim γ fγ (f₂ b)
x : β a₁
⊢ f₁ x = f₂ x
Theorem: ofAdd_multiset_prod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp [ofAdd]
state_before: ι : Type ?u.999738
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddCommMonoid α
s : Multiset α
⊢ ↑ofAdd (Multiset.sum s) = Multiset.prod (Multiset.map (↑ofAdd) s)

tactic: rfl
state_before: ι : Type ?u.999738
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddCommMonoid α
s : Multiset α
⊢ Multiset.sum s = Multiset.prod s
Theorem: Colex.colex_lt_of_ssubset
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [← sdiff_lt_sdiff_iff_lt, sdiff_eq_empty_iff_subset.2 h.1]
state_before: α : Type u_1
inst✝ : LinearOrder α
A B : Finset α
h : A ⊂ B
⊢ toColex A < toColex B

tactic: exact empty_toColex_lt (by simpa [Finset.Nonempty] using exists_of_ssubset h)
state_before: α : Type u_1
inst✝ : LinearOrder α
A B : Finset α
h : A ⊂ B
⊢ toColex ∅ < toColex (B \ A)

tactic: simpa [Finset.Nonempty] using exists_of_ssubset h
state_before: α : Type u_1
inst✝ : LinearOrder α
A B : Finset α
h : A ⊂ B
⊢ Finset.Nonempty (B \ A)
Theorem: Polynomial.degree_quadratic_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [add_assoc] using
  degree_add_le_of_degree_le (degree_C_mul_X_pow_le 2 a)
    (le_trans degree_linear_le <| WithBot.coe_le_coe.mpr one_le_two)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.936788
⊢ degree (↑C a * X ^ 2 + ↑C b * X + ↑C c) ≤ 2
Theorem: Set.preimage_const_add_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) ⁻¹' Ioc b c = Ioc (b - a) (c - a)
Theorem: Ordinal.type_uLift
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp
state_before: α : Type u
β : Type ?u.103331
γ : Type ?u.103334
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ type (ULift.down ⁻¹'o r) = lift (type r)

tactic: rfl
state_before: α : Type u
β : Type ?u.103331
γ : Type ?u.103334
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ (type fun x y => r x.down y.down) = lift (type r)
Theorem: Bool.and_xor_distrib_left
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> simp
state_before: a b c : Bool
⊢ (a && xor b c) = xor (a && b) (a && c)