tasksource/leandojo huggingface dataset:
Theorem: LinearMap.splittingOfFinsuppSurjective_splits
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: refine lhom_ext' fun x => ext_ring <| Finsupp.ext fun y => ?_
state_before: R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
⊢ comp f (splittingOfFinsuppSurjective f s) = id

tactic: dsimp [splittingOfFinsuppSurjective]
state_before: R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
x y : α
⊢ ↑(↑(comp (comp f (splittingOfFinsuppSurjective f s)) (lsingle x)) 1) y = ↑(↑(comp id (lsingle x)) 1) y

tactic: congr
state_before: R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
x y : α
⊢ ↑(↑f (sum (Finsupp.single x 1) fun x r => r • Exists.choose (_ : ∃ a, ↑f a = Finsupp.single x 1))) y =
    ↑(Finsupp.single x 1) y

tactic: rw [sum_single_index, one_smul]
state_before: case e_a
R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
x y : α
⊢ ↑f (sum (Finsupp.single x 1) fun x r => r • Exists.choose (_ : ∃ a, ↑f a = Finsupp.single x 1)) = Finsupp.single x 1

tactic: exact (s (Finsupp.single x 1)).choose_spec
state_before: case e_a
R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
x y : α
⊢ ↑f (Exists.choose (_ : ∃ a, ↑f a = Finsupp.single x 1)) = Finsupp.single x 1

tactic: rw [zero_smul]
state_before: case e_a
R : Type u_1
M : Type u_2
N : Type ?u.770436
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
α : Type u_3
f : M →ₗ[R] α →₀ R
s : Surjective ↑f
x y : α
⊢ 0 • Exists.choose (_ : ∃ a, ↑f a = Finsupp.single x 1) = 0
Theorem: abs_mul
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [abs_eq (mul_nonneg (abs_nonneg a) (abs_nonneg b))]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a✝ b✝ c a b : α
⊢ abs (a * b) = abs a * abs b

tactic: cases' le_total a 0 with ha ha <;> cases' le_total b 0 with hb hb <;>
  simp only [abs_of_nonpos, abs_of_nonneg, true_or_iff, or_true_iff, eq_self_iff_true, neg_mul,
    mul_neg, neg_neg, *]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a✝ b✝ c a b : α
⊢ a * b = abs a * abs b ∨ a * b = -(abs a * abs b)
Theorem: wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg
File: Mathlib/Analysis/Convex/Between.lean

tactic: convert wbtw_smul_vadd_smul_vadd_of_nonneg_of_le (r₁ • v +ᵥ x) v (Left.nonneg_neg_iff.2 hr₁)
    (neg_le_sub_iff_le_add.2 ((le_add_iff_nonneg_left r₁).2 hr₂)) using 1 <;>
  simp [sub_smul, ← add_vadd]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.554527
P : Type u_3
P' : Type ?u.554533
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : r₁ ≤ 0
hr₂ : 0 ≤ r₂
⊢ Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x)
Theorem: Submonoid.LocalizationMap.lift_comp
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: ext
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)
⊢ MonoidHom.comp (lift f hg) (toMap f) = g

tactic: exact f.lift_eq hg _
state_before: case h
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
⊢ ↑(MonoidHom.comp (lift f hg) (toMap f)) x✝ = ↑g x✝
Theorem: Submonoid.leftInvEquiv_mul
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: simpa only [leftInvEquiv_apply, fromCommLeftInv] using fromLeftInv_mul S x
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ leftInv S }
⊢ ↑(↑(leftInvEquiv S hS) x) * ↑x = 1
Theorem: Finmap.not_mem_erase_self
File: Mathlib/Data/Finmap.lean

tactic: rw [mem_erase, not_and_or, not_not]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : Finmap β
⊢ ¬a ∈ erase a s

tactic: left
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : Finmap β
⊢ a = a ∨ ¬a ∈ s

tactic: rfl
state_before: case h
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : Finmap β
⊢ a = a
Theorem: leftCoset_eq_iff
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [Set.ext_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ x *l ↑s = y *l ↑s ↔ x⁻¹ * y ∈ s

tactic: simp_rw [mem_leftCoset_iff, SetLike.mem_coe]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∀ (x_1 : α), x_1 ∈ x *l ↑s ↔ x_1 ∈ y *l ↑s) ↔ x⁻¹ * y ∈ s

tactic: constructor
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s) ↔ x⁻¹ * y ∈ s

tactic: intro h
state_before: case mp
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s) → x⁻¹ * y ∈ s

tactic: apply (h y).mpr
state_before: case mp
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : ∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s
⊢ x⁻¹ * y ∈ s

tactic: rw [mul_left_inv]
state_before: case mp
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : ∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s
⊢ y⁻¹ * y ∈ s

tactic: exact s.one_mem
state_before: case mp
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : ∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s
⊢ 1 ∈ s

tactic: intro h z
state_before: case mpr
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ x⁻¹ * y ∈ s → ∀ (x_1 : α), x⁻¹ * x_1 ∈ s ↔ y⁻¹ * x_1 ∈ s

tactic: rw [← mul_inv_cancel_right x⁻¹ y]
state_before: case mpr
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : x⁻¹ * y ∈ s
z : α
⊢ x⁻¹ * z ∈ s ↔ y⁻¹ * z ∈ s

tactic: rw [mul_assoc]
state_before: case mpr
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : x⁻¹ * y ∈ s
z : α
⊢ x⁻¹ * y * y⁻¹ * z ∈ s ↔ y⁻¹ * z ∈ s

tactic: exact s.mul_mem_cancel_left h
state_before: case mpr
α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
h : x⁻¹ * y ∈ s
z : α
⊢ x⁻¹ * y * (y⁻¹ * z) ∈ s ↔ y⁻¹ * z ∈ s
Theorem: MeasureTheory.withDensity_indicator
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: ext1 t ht
state_before: α : Type u_1
β : Type ?u.1768900
γ : Type ?u.1768903
δ : Type ?u.1768906
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hs : MeasurableSet s
f : α → ℝ≥0∞
⊢ withDensity μ (indicator s f) = withDensity (Measure.restrict μ s) f

tactic: rw [withDensity_apply _ ht, lintegral_indicator _ hs, restrict_comm hs, ←
  withDensity_apply _ ht]
state_before: case h
α : Type u_1
β : Type ?u.1768900
γ : Type ?u.1768903
δ : Type ?u.1768906
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hs : MeasurableSet s
f : α → ℝ≥0∞
t : Set α
ht : MeasurableSet t
⊢ ↑↑(withDensity μ (indicator s f)) t = ↑↑(withDensity (Measure.restrict μ s) f) t
Theorem: LinearOrderedField.smul_Ioi
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: ext x
state_before: α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
⊢ r • Ioi a = Ioi (r • a)

tactic: simp only [mem_smul_set, smul_eq_mul, mem_Ioi]
state_before: case h
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Ioi a ↔ x ∈ Ioi (r • a)

tactic: constructor
state_before: case h
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, a < y ∧ r * y = x) ↔ r * a < x

tactic: rintro ⟨a_w, a_h_left, rfl⟩
state_before: case h.mp
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, a < y ∧ r * y = x) → r * a < x

tactic: exact (mul_lt_mul_left hr).mpr a_h_left
state_before: case h.mp.intro.intro
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
a_w : K
a_h_left : a < a_w
⊢ r * a < r * a_w

tactic: rintro h
state_before: case h.mpr
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ r * a < x → ∃ y, a < y ∧ r * y = x

tactic: use x / r
state_before: case h.mpr
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : r * a < x
⊢ ∃ y, a < y ∧ r * y = x

tactic: constructor
state_before: case h.mpr
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : r * a < x
⊢ a < x / r ∧ r * (x / r) = x

tactic: exact (lt_div_iff' hr).mpr h
state_before: case h.mpr.left
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : r * a < x
⊢ a < x / r

case h.mpr.right
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : r * a < x
⊢ r * (x / r) = x

tactic: exact mul_div_cancel' _ (ne_of_gt hr)
state_before: case h.mpr.right
α : Type ?u.61362
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : r * a < x
⊢ r * (x / r) = x
Theorem: Multiset.toFinset_bind_dedup
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [toFinset, dedup_bind_dedup]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.453885
inst✝¹ : DecidableEq α
s t : Multiset α
inst✝ : DecidableEq β
m : Multiset α
f : α → Multiset β
⊢ toFinset (bind (dedup m) f) = toFinset (bind m f)
Theorem: Nat.odd_iff_not_even
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [not_even_iff, odd_iff]
state_before: m n : ℕ
⊢ Odd n ↔ ¬Even n
Theorem: SimpleGraph.bot_strongly_regular
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: simp only [card_eq_zero, Fintype.card_ofFinset, forall_true_left, not_false_iff, bot_adj]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
_h : v ≠ w
⊢ ¬Adj ⊥ v w → Fintype.card ↑(commonNeighbors ⊥ v w) = 0

tactic: ext
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
_h : v ≠ w
⊢ filter (fun x => x ∈ commonNeighbors ⊥ v w) univ = ∅

tactic: simp [mem_commonNeighbors]
state_before: case a
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
_h : v ≠ w
a✝ : V
⊢ a✝ ∈ filter (fun x => x ∈ commonNeighbors ⊥ v w) univ ↔ a✝ ∈ ∅
Theorem: Nat.eq_add_of_sub_eq
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [h.symm, Nat.sub_add_cancel hle]
state_before: a b c : Nat
hle : b ≤ a
h : a - b = c
⊢ a = c + b
Theorem: prevD_comp_right
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [prevD]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g✝ : C ⟶ D
h k : D ⟶ E
i : ι
f : (i j : ι) → X C i ⟶ X D j
g : D ⟶ E
j : ι
⊢ (↑(prevD j) fun i j => f i j ≫ Hom.f g j) = ↑(prevD j) f ≫ Hom.f g j

tactic: simp only [Category.assoc, g.comm]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g✝ : C ⟶ D
h k : D ⟶ E
i : ι
f : (i j : ι) → X C i ⟶ X D j
g : D ⟶ E
j : ι
⊢ (f j (ComplexShape.prev c j) ≫ Hom.f g (ComplexShape.prev c j)) ≫ d E (ComplexShape.prev c j) j =
    (f j (ComplexShape.prev c j) ≫ d D (ComplexShape.prev c j) j) ≫ Hom.f g j
Theorem: CategoryTheory.Limits.Fork.app_one_eq_ι_comp_right
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← s.app_zero_eq_ι, ← s.w right, parallelPair_map_right]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Fork f g
⊢ s.π.app one = ι s ≫ g
Theorem: Nat.not_two_dvd_bit1
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rw [bit1, Nat.dvd_add_right two_dvd_bit0, Nat.dvd_one]
state_before: a b m n✝ k n : ℕ
⊢ ¬2 ∣ bit1 n

tactic: decide
state_before: a b m n✝ k n : ℕ
⊢ ¬2 = 1
Theorem: Finset.prod_piecewise
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: erw [prod_ite, filter_mem_eq_inter, ← sdiff_eq_filter]
state_before: ι : Type ?u.770262
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s t : Finset α
f g : α → β
⊢ ∏ x in s, piecewise t f g x = (∏ x in s ∩ t, f x) * ∏ x in s \ t, g x
Theorem: CategoryTheory.Limits.map_inl_inv_coprodComparison
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝⁶ : Category C
X Y : C
D : Type u₂
inst✝⁵ : Category D
F : C ⥤ D
A A' B B' : C
inst✝⁴ : HasBinaryCoproduct A B
inst✝³ : HasBinaryCoproduct A' B'
inst✝² : HasBinaryCoproduct (F.obj A) (F.obj B)
inst✝¹ : HasBinaryCoproduct (F.obj A') (F.obj B')
inst✝ : IsIso (coprodComparison F A B)
⊢ F.map coprod.inl ≫ inv (coprodComparison F A B) = coprod.inl
Theorem: Finpartition.IsEquipartition.average_le_card_part
File: Mathlib/Order/Partition/Equipartition.lean

tactic: rw [← P.sum_card_parts]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : IsEquipartition P
ht : t ∈ P.parts
⊢ Finset.card s / Finset.card P.parts ≤ Finset.card t

tactic: exact Finset.EquitableOn.le hP ht
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : IsEquipartition P
ht : t ∈ P.parts
⊢ (Finset.sum P.parts fun i => Finset.card i) / Finset.card P.parts ≤ Finset.card t
Theorem: UniqueFactorizationMonoid.exists_associated_prime_pow_of_unique_normalized_factor
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: use Multiset.card.toFun (normalizedFactors r)
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
⊢ ∃ i, p ^ i ~ᵤ r

tactic: have := UniqueFactorizationMonoid.normalizedFactors_prod hr
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
⊢ p ^ ZeroHom.toFun (↑Multiset.card) (normalizedFactors r) ~ᵤ r

tactic: rwa [Multiset.eq_replicate_of_mem fun b => h, Multiset.prod_replicate] at this
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
this : Multiset.prod (normalizedFactors r) ~ᵤ r
⊢ p ^ ZeroHom.toFun (↑Multiset.card) (normalizedFactors r) ~ᵤ r
Theorem: Ordinal.bsup_eq_blsub_iff_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← sup_eq_bsup, ← lsub_eq_blsub]
state_before: α : Type ?u.356089
β : Type ?u.356092
γ : Type ?u.356095
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ bsup o f = blsub o f ↔ ∀ (a : Ordinal), a < blsub o f → succ a < blsub o f

tactic: apply sup_eq_lsub_iff_succ
state_before: α : Type ?u.356089
β : Type ?u.356092
γ : Type ?u.356095
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ sup (familyOfBFamily o f) = lsub (familyOfBFamily o f) ↔
    ∀ (a : Ordinal), a < lsub (familyOfBFamily o f) → succ a < lsub (familyOfBFamily o f)
Theorem: Turing.PartrecToTM2.codeSupp_comp
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [codeSupp, codeSupp', contSupp, Finset.union_assoc]
state_before: f g : Code
k : Cont'
⊢ codeSupp (Code.comp f g) k = trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k)

tactic: rw [← Finset.union_assoc _ _ (contSupp k),
  Finset.union_eq_right_iff_subset.2 (codeSupp'_self _ _)]
state_before: f g : Code
k : Cont'
⊢ trStmts₁ (trNormal g (Cont'.comp f k)) ∪
      (codeSupp' g (Cont'.comp f k) ∪ (trStmts₁ (trNormal f k) ∪ (codeSupp' f k ∪ contSupp k))) =
    trStmts₁ (trNormal g (Cont'.comp f k)) ∪ (codeSupp' g (Cont'.comp f k) ∪ (codeSupp' f k ∪ contSupp k))
Theorem: Pell.xn_modEq_x2n_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have : 2 * n - j + j ≤ n + j := by
  rw [tsub_add_cancel_of_le h, two_mul]; exact Nat.add_le_add_left jn _
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]

tactic: let t := xn_modEq_x2n_sub_lem a1 (Nat.le_of_add_le_add_right this)
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]

tactic: rwa [tsub_tsub_cancel_of_le h, add_comm] at t
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
this : 2 * n - j + j ≤ n + j
t : xn a1 (2 * n - (2 * n - j)) + xn a1 (2 * n - j) ≡ 0 [MOD xn a1 n] :=
  xn_modEq_x2n_sub_lem a1 (Nat.le_of_add_le_add_right this)
⊢ xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]

tactic: rw [tsub_add_cancel_of_le h, two_mul]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
⊢ 2 * n - j + j ≤ n + j

tactic: exact Nat.add_le_add_left jn _
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
h : j ≤ 2 * n
jn : n ≤ j
⊢ n + n ≤ n + j
Theorem: intervalIntegral.integral_const
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [integral_const', Real.volume_Ioc, ENNReal.toReal_ofReal', ← neg_sub b,
  max_zero_sub_eq_self]
state_before: ι : Type ?u.13713922
𝕜 : Type ?u.13713925
E : Type u_1
F : Type ?u.13713931
A : Type ?u.13713934
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
c : E
⊢ (∫ (x : ℝ) in a..b, c) = (b - a) • c
Theorem: Multiset.range_succ
File: Mathlib/Data/Multiset/Range.lean

tactic: rw [range, List.range_succ, ← coe_add, add_comm]
state_before: n : ℕ
⊢ range (succ n) = n ::ₘ range n

tactic: rfl
state_before: n : ℕ
⊢ ↑[n] + ↑(List.range n) = n ::ₘ range n
Theorem: map_iSup
File: Mathlib/Order/Hom/CompleteLattice.lean

tactic: simp [iSup, ← Set.range_comp, Function.comp]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.3707
δ : Type ?u.3710
ι : Sort u_4
κ : ι → Sort ?u.3718
inst✝² : SupSet α
inst✝¹ : SupSet β
inst✝ : sSupHomClass F α β
f : F
g : ι → α
⊢ ↑f (⨆ (i : ι), g i) = ⨆ (i : ι), ↑f (g i)
Theorem: Composition.boundary_zero
File: Mathlib/Combinatorics/Composition.lean

tactic: simp [boundary, Fin.ext_iff]
state_before: n : ℕ
c : Composition n
⊢ ↑(boundary c) 0 = 0
Theorem: Finset.inter_insert_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, insert_inter_of_mem h, inter_comm]
state_before: α : Type u_1
β : Type ?u.184956
γ : Type ?u.184959
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₁
⊢ s₁ ∩ insert a s₂ = insert a (s₁ ∩ s₂)
Theorem: sup_left_right_swap
File: Mathlib/Order/Lattice.lean

tactic: rw [sup_comm, @sup_comm _ _ a, sup_assoc]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ b ⊔ c = c ⊔ b ⊔ a
Theorem: CategoryTheory.transferNatTransSelf_id
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₃
⊢ ↑(transferNatTransSelf adj₁ adj₁) (𝟙 L₁) = 𝟙 R₁

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₃
x✝ : D
⊢ (↑(transferNatTransSelf adj₁ adj₁) (𝟙 L₁)).app x✝ = (𝟙 R₁).app x✝

tactic: simp
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₃
x✝ : D
⊢ 𝟙 (R₁.obj x✝) ≫
      (adj₁.unit.app (R₁.obj x✝) ≫
          R₁.map ((𝟙 (L₁.obj (R₁.obj x✝)) ≫ 𝟙 (L₁.obj (R₁.obj x✝)) ≫ 𝟙 (L₁.obj (R₁.obj x✝))) ≫ adj₁.counit.app x✝)) ≫
        𝟙 (R₁.obj x✝) =
    𝟙 (R₁.obj x✝)
Theorem: Mathlib.Meta.NormNum.IsRat.to_isNat
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
a✝ : ℕ
inv : Invertible ↑1
this : Invertible 1
⊢ ↑(Int.ofNat a✝) * ⅟↑1 = ↑a✝
Theorem: CategoryTheory.isSeparator_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsSeparator, IsCoseparator, ← isSeparating_unop_iff, Set.singleton_unop]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : Cᵒᵖ
⊢ IsSeparator G.unop ↔ IsCoseparator G
Theorem: MeasureTheory.set_integral_nonpos_le
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← integral_indicator hs, ←
  integral_indicator (hf.measurableSet_le stronglyMeasurable_const)]
state_before: α : Type u_1
β : Type ?u.297696
E : Type ?u.297699
F : Type ?u.297702
inst✝ : MeasurableSpace α
μ : Measure α
f : α → ℝ
s✝ s : Set α
hs : MeasurableSet s
hf : StronglyMeasurable f
hfi : Integrable f
⊢ (∫ (x : α) in {y | f y ≤ 0}, f x ∂μ) ≤ ∫ (x : α) in s, f x ∂μ

tactic: exact
  integral_mono (hfi.indicator (hf.measurableSet_le stronglyMeasurable_const))
    (hfi.indicator hs) (indicator_nonpos_le_indicator s f)
state_before: α : Type u_1
β : Type ?u.297696
E : Type ?u.297699
F : Type ?u.297702
inst✝ : MeasurableSpace α
μ : Measure α
f : α → ℝ
s✝ s : Set α
hs : MeasurableSet s
hf : StronglyMeasurable f
hfi : Integrable f
⊢ (∫ (x : α), indicator {a | f a ≤ 0} (fun x => f x) x ∂μ) ≤ ∫ (x : α), indicator s (fun x => f x) x ∂μ
Theorem: Polynomial.update_zero_eq_erase
File: Mathlib/Data/Polynomial/Basic.lean

tactic: ext
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
⊢ update p n 0 = erase n p

tactic: rw [coeff_update_apply, coeff_erase]
state_before: case a
R : Type u
a b : R
m n✝¹ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n n✝ : ℕ
⊢ coeff (update p n 0) n✝ = coeff (erase n p) n✝
Theorem: Equiv.Perm.length_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp [toList]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
⊢ length (toList p x) = Finset.card (support (cycleOf p x))
Theorem: DirectSum.coe_decompose_mul_of_left_mem_of_le
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: lift a to 𝒜 i using a_mem
state_before: ι : Type u_3
R : Type ?u.357840
A : Type u_1
σ : Type u_2
inst✝⁸ : Semiring A
inst✝⁷ : DecidableEq ι
inst✝⁶ : CanonicallyOrderedAddMonoid ι
inst✝⁵ : SetLike σ A
inst✝⁴ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝³ : GradedRing 𝒜
a b : A
n i : ι
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a_mem : a ∈ 𝒜 i
h : i ≤ n
⊢ ↑(↑(↑(decompose 𝒜) (a * b)) n) = a * ↑(↑(↑(decompose 𝒜) b) (n - i))

tactic: rwa [decompose_mul, decompose_coe, coe_of_mul_apply_of_le]
state_before: case intro
ι : Type u_3
R : Type ?u.357840
A : Type u_1
σ : Type u_2
inst✝⁸ : Semiring A
inst✝⁷ : DecidableEq ι
inst✝⁶ : CanonicallyOrderedAddMonoid ι
inst✝⁵ : SetLike σ A
inst✝⁴ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝³ : GradedRing 𝒜
b : A
n i : ι
inst✝² : Sub ι
inst✝¹ : OrderedSub ι
inst✝ : ContravariantClass ι ι (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : i ≤ n
a : { x // x ∈ 𝒜 i }
⊢ ↑(↑(↑(decompose 𝒜) (↑a * b)) n) = ↑a * ↑(↑(↑(decompose 𝒜) b) (n - i))