tasksource/leandojo huggingface dataset:
Theorem: DirectSum.toAddMonoidAlgebra_mul
File: Mathlib/Algebra/MonoidAlgebra/ToDirectSum.lean

tactic: apply_fun AddMonoidAlgebra.toDirectSum
state_before: ι : Type u_1
R : Type ?u.136196
M : Type u_2
A : Type ?u.136202
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ toAddMonoidAlgebra (f * g) = toAddMonoidAlgebra f * toAddMonoidAlgebra g

tactic: simp
state_before: ι : Type u_1
R : Type ?u.136196
M : Type u_2
A : Type ?u.136202
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ AddMonoidAlgebra.toDirectSum (toAddMonoidAlgebra (f * g)) =
    AddMonoidAlgebra.toDirectSum (toAddMonoidAlgebra f * toAddMonoidAlgebra g)

tactic: apply Function.LeftInverse.injective
state_before: case inj
ι : Type u_1
R : Type ?u.136196
M : Type u_2
A : Type ?u.136202
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ Function.Injective AddMonoidAlgebra.toDirectSum

tactic: apply AddMonoidAlgebra.toDirectSum_toAddMonoidAlgebra
state_before: case inj.a
ι : Type u_1
R : Type ?u.136196
M : Type u_2
A : Type ?u.136202
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ Function.LeftInverse ?inj.g AddMonoidAlgebra.toDirectSum

case inj.g
ι : Type u_1
R : Type ?u.136196
M : Type u_2
A : Type ?u.136202
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ (⨁ (x : ι), M) → AddMonoidAlgebra M ι
Theorem: associated_zero_iff_eq_zero
File: Mathlib/Algebra/Associated.lean

tactic: let ⟨u, h⟩ := h.symm
state_before: α : Type u_1
β : Type ?u.151491
γ : Type ?u.151494
δ : Type ?u.151497
inst✝ : MonoidWithZero α
a : α
h : a ~ᵤ 0
⊢ a = 0

tactic: simpa using h.symm
state_before: α : Type u_1
β : Type ?u.151491
γ : Type ?u.151494
δ : Type ?u.151497
inst✝ : MonoidWithZero α
a : α
h✝ : a ~ᵤ 0
u : αˣ
h : 0 * ↑u = a
⊢ a = 0
Theorem: List.eraseP_map
File: Std/Data/List/Lemmas.lean

tactic: by_cases h : p (f b) <;> simp [h, eraseP_map f l, eraseP_cons_of_pos]
state_before: β : Type u_1
α : Type u_2
p : α → Bool
f : β → α
b : β
l : List β
⊢ eraseP p (map f (b :: l)) = map f (eraseP (p ∘ f) (b :: l))
Theorem: TensorProduct.one_smul
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: rw [TensorProduct.smul_zero]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_4
inst✝¹⁵ : Monoid R'
R'' : Type ?u.221106
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.221118
Q : Type ?u.221121
S : Type ?u.221124
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
x : M ⊗[R] N
this : ∀ (r : R') (m : M) (n : N), r • m ⊗ₜ[R] n = (r • m) ⊗ₜ[R] n
⊢ 1 • 0 = 0

tactic: rw [this, one_smul]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_4
inst✝¹⁵ : Monoid R'
R'' : Type ?u.221106
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.221118
Q : Type ?u.221121
S : Type ?u.221124
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
x : M ⊗[R] N
this : ∀ (r : R') (m : M) (n : N), r • m ⊗ₜ[R] n = (r • m) ⊗ₜ[R] n
m : M
n : N
⊢ 1 • m ⊗ₜ[R] n = m ⊗ₜ[R] n

tactic: rw [TensorProduct.smul_add, ihx, ihy]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_4
inst✝¹⁵ : Monoid R'
R'' : Type ?u.221106
inst✝¹⁴ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.221118
Q : Type ?u.221121
S : Type ?u.221124
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
x✝ : M ⊗[R] N
this : ∀ (r : R') (m : M) (n : N), r • m ⊗ₜ[R] n = (r • m) ⊗ₜ[R] n
x y : M ⊗[R] N
ihx : 1 • x = x
ihy : 1 • y = y
⊢ 1 • (x + y) = x + y
Theorem: Mon_.mul_associator
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫ (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
      (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))

tactic: slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))

tactic: slice_lhs 3 4 => rw [associator_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      ((tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ ((M.mul ⊗ N.mul) ⊗ P.mul)) ≫ (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))

tactic: slice_rhs 3 4 => rw [← Category.id_comp M.mul, tensor_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫
        (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom ≫ (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))

tactic: slice_lhs 1 3 => rw [associator_monoidal]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫
        (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom ≫ (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)

tactic: simp only [Category.assoc]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ (((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X))) ≫
      (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)
Theorem: AlgebraicTopology.DoldKan.N₁Γ₀_app
File: Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean

tactic: ext1
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ N₁Γ₀.app K =
    (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).symm ≪≫
      (toKaroubi (ChainComplex C ℕ)).mapIso (Γ₀NondegComplexIso K)

tactic: dsimp [N₁Γ₀]
state_before: case w
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ (N₁Γ₀.app K).hom =
    ((Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).symm ≪≫
        (toKaroubi (ChainComplex C ℕ)).mapIso (Γ₀NondegComplexIso K)).hom

tactic: erw [id_comp, comp_id, comp_id]
state_before: case w
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ (((Karoubi.Hom.mk PInfty ≫ Split.toKaroubiNondegComplexFunctorIsoN₁.inv.app (Split.mk' (Γ₀.splitting K))) ≫
          Karoubi.Hom.mk (𝟙 (Splitting.nondegComplex (Γ₀.splitting K)))) ≫
        (toKaroubi (ChainComplex C ℕ)).map (Γ₀'CompNondegComplexFunctor.hom.app K)) ≫
      Karoubi.Hom.mk (𝟙 K) =
    (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).inv ≫
      (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom

tactic: rfl
state_before: case w
C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
⊢ Split.toKaroubiNondegComplexFunctorIsoN₁.inv.app (Split.mk' (Γ₀.splitting K)) ≫
      (toKaroubi (ChainComplex C ℕ)).map (Γ₀'CompNondegComplexFunctor.hom.app K) =
    (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).inv ≫
      (toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).hom
Theorem: tendsto_nat_floor_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simp [Nat.le_floor_iff]
state_before: α✝ : Type ?u.493938
β : Type ?u.493941
ι : Type ?u.493944
α : Type u_1
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
x : ℕ
⊢ x ≤ ⌊max 0 (↑x + 1)⌋₊
Theorem: meas_lt_essInf
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp_rw [← not_le]
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝³ : ConditionallyCompleteLinearOrder β
x : β
f : α → β
inst✝² : TopologicalSpace β
inst✝¹ : FirstCountableTopology β
inst✝ : OrderTopology β
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) (Measure.ae μ) f) _auto✝
⊢ ↑↑μ {y | f y < essInf f μ} = 0

tactic: exact ae_essInf_le hf
state_before: α : Type u_2
β : Type u_1
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝³ : ConditionallyCompleteLinearOrder β
x : β
f : α → β
inst✝² : TopologicalSpace β
inst✝¹ : FirstCountableTopology β
inst✝ : OrderTopology β
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) (Measure.ae μ) f) _auto✝
⊢ ↑↑μ {y | ¬essInf f μ ≤ f y} = 0
Theorem: sdiff_sup_self
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_comm, sup_sdiff_self, sup_comm]
state_before: ι : Type ?u.91987
α : Type u_1
β : Type ?u.91993
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
⊢ b \ a ⊔ a = b ⊔ a
Theorem: Submodule.linear_proj_add_linearProjOfIsCompl_eq_self
File: Mathlib/LinearAlgebra/Projection.lean

tactic: dsimp only [linearProjOfIsCompl]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.186731
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.187247
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.188210
inst✝² : Semiring S
M : Type ?u.188216
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑(↑(linearProjOfIsCompl p q hpq) x) + ↑(↑(linearProjOfIsCompl q p (_ : IsCompl q p)) x) = x

tactic: rw [← prodComm_trans_prodEquivOfIsCompl _ _ hpq]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.186731
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.187247
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.188210
inst✝² : Semiring S
M : Type ?u.188216
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑(↑(comp (LinearMap.fst R { x // x ∈ p } { x // x ∈ q }) ↑(LinearEquiv.symm (prodEquivOfIsCompl p q hpq))) x) +
      ↑(↑(comp (LinearMap.fst R { x // x ∈ q } { x // x ∈ p })
              ↑(LinearEquiv.symm (prodEquivOfIsCompl q p (_ : IsCompl q p))))
          x) =
    x

tactic: exact (prodEquivOfIsCompl _ _ hpq).apply_symm_apply x
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.186731
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.187247
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.188210
inst✝² : Semiring S
M : Type ?u.188216
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑(↑(comp (LinearMap.fst R { x // x ∈ p } { x // x ∈ q }) ↑(LinearEquiv.symm (prodEquivOfIsCompl p q hpq))) x) +
      ↑(↑(comp (LinearMap.fst R { x // x ∈ q } { x // x ∈ p })
              ↑(LinearEquiv.symm
                  (LinearEquiv.trans (LinearEquiv.prodComm R { x // x ∈ q } { x // x ∈ p })
                    (prodEquivOfIsCompl p q hpq))))
          x) =
    x
Theorem: List.unzip_eq_unzipTR
File: Std/Data/List/Basic.lean

tactic: funext α β l
state_before: ⊢ @unzip = @unzipTR

tactic: simp [unzipTR]
state_before: case h.h.h
α : Type u_2
β : Type u_1
l : List (α × β)
⊢ unzip l = unzipTR l

tactic: induction l <;> simp [*]
state_before: case h.h.h
α : Type u_2
β : Type u_1
l : List (α × β)
⊢ unzip l = foldr (fun x x_1 => (x.fst :: x_1.fst, x.snd :: x_1.snd)) ([], []) l
Theorem: Mod_.id_hom'
File: Mathlib/CategoryTheory/Monoidal/Mod_.lean

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
A : Mon_ C
M✝ M : Mod_ A
⊢ (𝟙 M).hom = 𝟙 M.X
Theorem: MeasureTheory.ae_eq_empty
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp only [ae_iff, Classical.not_not, setOf_mem_eq]
state_before: α : Type u_1
β : Type ?u.101184
γ : Type ?u.101187
δ : Type ?u.101190
ι : Type ?u.101193
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ (∀ᵐ (x : α) ∂μ, ¬x ∈ s) ↔ ↑↑μ s = 0
Theorem: mul_one_add
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [mul_add, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : LeftDistribClass α
a b : α
⊢ a * (1 + b) = a + a * b
Theorem: CategoryTheory.FreeBicategory.preinclusion_map₂
File: Mathlib/CategoryTheory/Bicategory/Coherence.lean

tactic: rcases η with ⟨⟨⟩⟩
state_before: B : Type u
inst✝ : Quiver B
a b : B
f g : Discrete (Path a b)
η : f ⟶ g
⊢ PrelaxFunctor.map₂ (preinclusion B) η = eqToHom (_ : (↑(preinclusion B)).map f = (↑(preinclusion B)).map g)

tactic: cases Discrete.ext _ _ (by assumption)
state_before: case up.up
B : Type u
inst✝ : Quiver B
a b : B
f g : Discrete (Path a b)
down✝ : f.as = g.as
⊢ PrelaxFunctor.map₂ (preinclusion B) { down := { down := down✝ } } =
    eqToHom (_ : (↑(preinclusion B)).map f = (↑(preinclusion B)).map g)

tactic: convert (inclusionPath a b).map_id _
state_before: case up.up.refl
B : Type u
inst✝ : Quiver B
a b : B
f : Discrete (Path a b)
down✝ : f.as = f.as
⊢ PrelaxFunctor.map₂ (preinclusion B) { down := { down := down✝ } } =
    eqToHom (_ : (↑(preinclusion B)).map f = (↑(preinclusion B)).map f)

tactic: assumption
state_before: B : Type u
inst✝ : Quiver B
a b : B
f g : Discrete (Path a b)
down✝ : f.as = g.as
⊢ ?m.4788.as = ?m.4789.as
Theorem: UniqueMul.mt
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: contrapose! k
state_before: G✝ : Type ?u.271
H : Type ?u.274
inst✝² : Mul G✝
inst✝¹ : Mul H
A✝ B✝ : Finset G✝
a0✝ b0✝ : G✝
G : Type u_1
inst✝ : Mul G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x✝¹ x✝ : G
ha : x✝¹ ∈ A
hb : x✝ ∈ B
k : x✝¹ ≠ a0 ∨ x✝ ≠ b0
⊢ x✝¹ * x✝ ≠ a0 * b0

tactic: exact h ha hb k
state_before: G✝ : Type ?u.271
H : Type ?u.274
inst✝² : Mul G✝
inst✝¹ : Mul H
A✝ B✝ : Finset G✝
a0✝ b0✝ : G✝
G : Type u_1
inst✝ : Mul G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x✝¹ x✝ : G
ha : x✝¹ ∈ A
hb : x✝ ∈ B
k : x✝¹ * x✝ = a0 * b0
⊢ x✝¹ = a0 ∧ x✝ = b0
Theorem: Fin.reverse_induction_last
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [reverseInduction]
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C (last n)
hs : (i : Fin n) → C (succ i) → C (↑castSucc i)
⊢ reverseInduction h0 hs (last n) = h0

tactic: simp
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C (last n)
hs : (i : Fin n) → C (succ i) → C (↑castSucc i)
⊢ (if hi : last n = last n then _root_.cast (_ : C (last n) = C (last n)) h0
    else
      let j := { val := ↑(last n), isLt := (_ : ↑(last n) < n) };
      let_fun x := (_ : n - ↑(last n) < n + 1 - ↑(last n));
      let_fun hi := (_ : last n = ↑castSucc j);
      _root_.cast (_ : C (↑castSucc j) = C (last n)) (hs j (reverseInduction h0 hs (succ j)))) =
    h0
Theorem: Nat.succ_iterate
File: Mathlib/Data/Nat/SuccPred.lean

tactic: rw [Function.iterate_succ', add_succ]
state_before: a n : ℕ
⊢ (succ^[n + 1]) a = a + (n + 1)

tactic: exact congr_arg _ (succ_iterate a n)
state_before: a n : ℕ
⊢ (succ ∘ succ^[n]) a = succ (a + n)
Theorem: List.cyclicPermutations_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: refine' ext_nthLe this fun n hn hn' => _
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : length (cyclicPermutations (rotate l k)) = length (rotate (cyclicPermutations l) k)
⊢ cyclicPermutations (rotate l k) = rotate (cyclicPermutations l) k

tactic: rw [nthLe_rotate, nthLe_cyclicPermutations, rotate_rotate, ← rotate_mod, add_comm]
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : length (cyclicPermutations (rotate l k)) = length (rotate (cyclicPermutations l) k)
n : ℕ
hn : n < length (cyclicPermutations (rotate l k))
hn' : n < length (rotate (cyclicPermutations l) k)
⊢ nthLe (cyclicPermutations (rotate l k)) n hn = nthLe (rotate (cyclicPermutations l) k) n hn'

tactic: cases l <;> simp
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : length (cyclicPermutations (rotate l k)) = length (rotate (cyclicPermutations l) k)
n : ℕ
hn : n < length (cyclicPermutations (rotate l k))
hn' : n < length (rotate (cyclicPermutations l) k)
⊢ rotate l ((n + k) % length l) =
    nthLe (cyclicPermutations l) ((n + k) % length (cyclicPermutations l))
      (_ : (n + k) % length (cyclicPermutations l) < length (cyclicPermutations l))

tactic: cases l
state_before: α : Type u
l✝ l' l : List α
k : ℕ
⊢ length (cyclicPermutations (rotate l k)) = length (rotate (cyclicPermutations l) k)

tactic: simp
state_before: case nil
α : Type u
l l' : List α
k : ℕ
⊢ length (cyclicPermutations (rotate [] k)) = length (rotate (cyclicPermutations []) k)

tactic: rw [length_cyclicPermutations_of_ne_nil] <;> simp
state_before: case cons
α : Type u
l l' : List α
k : ℕ
head✝ : α
tail✝ : List α
⊢ length (cyclicPermutations (rotate (head✝ :: tail✝) k)) = length (rotate (cyclicPermutations (head✝ :: tail✝)) k)
Theorem: pow_div_pow_eventuallyEq_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

tactic: apply (eventually_gt_atTop (0 : 𝕜)).mono fun x hx => _
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ (fun x => x ^ p / x ^ q) =ᶠ[atTop] fun x => x ^ (↑p - ↑q)

tactic: intro x hx
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ ∀ (x : 𝕜), 0 < x → (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x

tactic: simp [zpow_sub₀ hx.ne']
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
x : 𝕜
hx : 0 < x
⊢ (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
Theorem: deriv_fderiv
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [deriv]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
⊢ smulRight 1 (deriv f x) = fderiv 𝕜 f x
Theorem: Finsupp.single_injective
File: Mathlib/Data/Finsupp/Defs.lean

tactic: have : (single a b₁ : α →₀ M) a = (single a b₂ : α →₀ M) a := by rw [eq]
state_before: α : Type u_2
β : Type ?u.49306
γ : Type ?u.49309
ι : Type ?u.49312
M : Type u_1
M' : Type ?u.49318
N : Type ?u.49321
P : Type ?u.49324
G : Type ?u.49327
H : Type ?u.49330
R : Type ?u.49333
S : Type ?u.49336
inst✝ : Zero M
a✝ a' : α
b : M
a : α
b₁ b₂ : M
eq : single a b₁ = single a b₂
⊢ b₁ = b₂

tactic: rwa [single_eq_same, single_eq_same] at this
state_before: α : Type u_2
β : Type ?u.49306
γ : Type ?u.49309
ι : Type ?u.49312
M : Type u_1
M' : Type ?u.49318
N : Type ?u.49321
P : Type ?u.49324
G : Type ?u.49327
H : Type ?u.49330
R : Type ?u.49333
S : Type ?u.49336
inst✝ : Zero M
a✝ a' : α
b : M
a : α
b₁ b₂ : M
eq : single a b₁ = single a b₂
this : ↑(single a b₁) a = ↑(single a b₂) a
⊢ b₁ = b₂

tactic: rw [eq]
state_before: α : Type u_2
β : Type ?u.49306
γ : Type ?u.49309
ι : Type ?u.49312
M : Type u_1
M' : Type ?u.49318
N : Type ?u.49321
P : Type ?u.49324
G : Type ?u.49327
H : Type ?u.49330
R : Type ?u.49333
S : Type ?u.49336
inst✝ : Zero M
a✝ a' : α
b : M
a : α
b₁ b₂ : M
eq : single a b₁ = single a b₂
⊢ ↑(single a b₁) a = ↑(single a b₂) a
Theorem: MeasureTheory.SignedMeasure.toMeasureOfLEZero_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: erw [toMeasureOfZeroLE_apply]
state_before: α : Type u_1
β : Type ?u.712523
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hi : restrict s i ≤ restrict 0 i
hi₁ : MeasurableSet i
hj₁ : MeasurableSet j
⊢ ↑↑(toMeasureOfLEZero s i hi₁ hi) j = ↑{ val := -↑s (i ∩ j), property := (_ : 0 ≤ -↑s (i ∩ j)) }

tactic: simp
state_before: α : Type u_1
β : Type ?u.712523
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hi : restrict s i ≤ restrict 0 i
hi₁ : MeasurableSet i
hj₁ : MeasurableSet j
⊢ ↑{ val := ↑(-s) (i ∩ j), property := (_ : 0 ≤ ↑(-s) (i ∩ j)) } =
    ↑{ val := -↑s (i ∩ j), property := (_ : 0 ≤ -↑s (i ∩ j)) }

tactic: assumption
state_before: case hj₁
α : Type u_1
β : Type ?u.712523
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hi : restrict s i ≤ restrict 0 i
hi₁ : MeasurableSet i
hj₁ : MeasurableSet j
⊢ MeasurableSet j
Theorem: MeasureTheory.lintegral_add_right'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simpa only [add_comm] using lintegral_add_left' hg f
state_before: α : Type u_1
β : Type ?u.903143
γ : Type ?u.903146
δ : Type ?u.903149
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
⊢ (∫⁻ (a : α), f a + g a ∂μ) = (∫⁻ (a : α), f a ∂μ) + ∫⁻ (a : α), g a ∂μ