tasksource/leandojo huggingface dataset:
Theorem: AddLECancellable.tsub_add_eq_add_tsub
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm a, hb.add_tsub_assoc_of_le h, add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
h : b ≤ a
⊢ a - b + c = a + c - b
Theorem: PrimeSpectrum.isRadical_vanishingIdeal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← vanishingIdeal_closure, ← zeroLocus_vanishingIdeal_eq_closure,
  vanishingIdeal_zeroLocus_eq_radical]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set (PrimeSpectrum R)
⊢ Ideal.IsRadical (vanishingIdeal s)

tactic: apply Ideal.radical_isRadical
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set (PrimeSpectrum R)
⊢ Ideal.IsRadical (Ideal.radical (vanishingIdeal s))
Theorem: NNReal.rpow_self_rpow_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: field_simp [← rpow_mul]
state_before: y : ℝ
hy : y ≠ 0
x : ℝ≥0
⊢ (x ^ (1 / y)) ^ y = x
Theorem: Real.sqrtTwoAddSeries_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ sqrtTwoAddSeries 0 1 = sqrt 2
Theorem: AlgHom.map_algebraMap
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: rw [algebraMap_apply R S A r, f.commutes, ← algebraMap_apply R S B]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra S A
inst✝⁴ : Algebra S B
inst✝³ : Algebra R A
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
r : R
⊢ ↑f (↑(algebraMap R A) r) = ↑(algebraMap R B) r
Theorem: CategoryTheory.eqToHom_comp_iff
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: simp
state_before: C : Type u₁
inst✝ : Category C
X X' Y : C
p : X = X'
f : X ⟶ Y
g : X' ⟶ Y
h : eqToHom p ≫ g = f
⊢ g = eqToHom (_ : X' = X) ≫ eqToHom p ≫ g

tactic: simp [whisker_eq _ h]
state_before: C : Type u₁
inst✝ : Category C
X X' Y : C
p : X = X'
f : X ⟶ Y
g : X' ⟶ Y
h : g = eqToHom (_ : X' = X) ≫ f
⊢ eqToHom p ≫ eqToHom (_ : X' = X) ≫ f = f
Theorem: ZNum.cast_sub
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : Ring α
m n : ZNum
⊢ ↑(m - n) = ↑m - ↑n
Theorem: AdjoinRoot.isRoot_root
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [IsRoot, eval_map, eval₂_root]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f✝ f : R[X]
⊢ IsRoot (Polynomial.map (of f) f) (root f)
Theorem: Finset.univ_filter_card_eq
File: Mathlib/Data/Fintype/Powerset.lean

tactic: ext
state_before: α✝ : Type ?u.1171
α : Type u_1
inst✝ : Fintype α
k : ℕ
⊢ filter (fun s => card s = k) univ = powersetLen k univ

tactic: simp [Finset.mem_powersetLen]
state_before: case a
α✝ : Type ?u.1171
α : Type u_1
inst✝ : Fintype α
k : ℕ
a✝ : Finset α
⊢ a✝ ∈ filter (fun s => card s = k) univ ↔ a✝ ∈ powersetLen k univ
Theorem: OreLocalization.ind
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: apply Quotient.ind
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
β : OreLocalization R S → Prop
c : ∀ (r : R) (s : { x // x ∈ S }), β (r /ₒ s)
⊢ ∀ (q : OreLocalization R S), β q

tactic: rintro ⟨r, s⟩
state_before: case a
R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
β : OreLocalization R S → Prop
c : ∀ (r : R) (s : { x // x ∈ S }), β (r /ₒ s)
⊢ ∀ (a : R × { x // x ∈ S }), β (Quotient.mk (oreEqv R S) a)

tactic: exact c r s
state_before: case a.mk
R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
β : OreLocalization R S → Prop
c : ∀ (r : R) (s : { x // x ∈ S }), β (r /ₒ s)
r : R
s : { x // x ∈ S }
⊢ β (Quotient.mk (oreEqv R S) (r, s))
Theorem: FirstOrder.Language.BoundedFormula.sup_semanticallyEquivalent_not_inf_not
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp [imp_iff_not_or]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ ψ : BoundedFormula L α n
M : Theory.ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ Realize (φ ⊔ ψ ⇔ ∼(∼φ ⊓ ∼ψ)) v xs
Theorem: Set.empty_card'
File: Mathlib/Data/Set/Finite.lean

tactic: congr
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
h : Fintype ↑∅
⊢ Fintype.card ↑∅ = Fintype.card ↑∅

tactic: exact Subsingleton.elim _ _
state_before: case h.e_2.h
α : Type u
β : Type v
ι : Sort w
γ : Type x
h : Fintype ↑∅
⊢ h = fintypeEmpty
Theorem: NonUnitalAlgHom.coe_distribMulActionHom_mk
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f : A →ₙₐ[R] B
h₁ : ∀ (m : R) (x : A), ↑f (m • x) = m • ↑f x
h₂ : MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } 0 = 0
h₃ :
  ∀ (x y : A),
    MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } (x + y) =
      MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } x + MulActionHom.toFun { toFun := ↑f, map_smul' := h₁ } y
h₄ :
  ∀ (x y : A),
    MulActionHom.toFun
        { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom (x * y) =
      MulActionHom.toFun
          { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom x *
        MulActionHom.toFun
          { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }.toMulActionHom y
⊢ ↑{ toDistribMulActionHom := { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ },
        map_mul' := h₄ } =
    { toMulActionHom := { toFun := ↑f, map_smul' := h₁ }, map_zero' := h₂, map_add' := h₃ }
Theorem: Cardinal.eq_of_add_eq_add_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases' le_or_lt ℵ₀ b with hb hb
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
⊢ b = c

tactic: have : a < b := ha.trans_le hb
state_before: case inl
a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : ℵ₀ ≤ b
⊢ b = c

tactic: rw [add_eq_right hb this.le, eq_comm] at h
state_before: case inl
a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : ℵ₀ ≤ b
this : a < b
⊢ b = c

tactic: rw [eq_of_add_eq_of_aleph0_le h this hb]
state_before: case inl
a b c : Cardinal
h : a + c = b
ha : a < ℵ₀
hb : ℵ₀ ≤ b
this : a < b
⊢ b = c

tactic: have hc : c < ℵ₀ := by
  rw [← not_le]
  intro hc
  apply lt_irrefl ℵ₀
  apply (hc.trans (self_le_add_left _ a)).trans_lt
  rw [← h]
  apply add_lt_aleph0 ha hb
state_before: case inr
a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
⊢ b = c

tactic: rw [lt_aleph0] at *
state_before: case inr
a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
hc : c < ℵ₀
⊢ b = c

tactic: rcases ha with ⟨n, rfl⟩
state_before: case inr
a b c : Cardinal
h : a + b = a + c
ha : ∃ n, a = ↑n
hb : ∃ n, b = ↑n
hc : ∃ n, c = ↑n
⊢ b = c

tactic: rcases hb with ⟨m, rfl⟩
state_before: case inr.intro
b c : Cardinal
hb : ∃ n, b = ↑n
hc : ∃ n, c = ↑n
n : ℕ
h : ↑n + b = ↑n + c
⊢ b = c

tactic: rcases hc with ⟨k, rfl⟩
state_before: case inr.intro.intro
c : Cardinal
hc : ∃ n, c = ↑n
n m : ℕ
h : ↑n + ↑m = ↑n + c
⊢ ↑m = c

tactic: norm_cast  at h⊢
state_before: case inr.intro.intro.intro
n m k : ℕ
h : ↑n + ↑m = ↑n + ↑k
⊢ ↑m = ↑k

tactic: apply add_left_cancel h
state_before: case inr.intro.intro.intro
n m k : ℕ
h : n + m = n + k
⊢ m = k

tactic: rw [← not_le]
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
⊢ c < ℵ₀

tactic: intro hc
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
⊢ ¬ℵ₀ ≤ c

tactic: apply lt_irrefl ℵ₀
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
hc : ℵ₀ ≤ c
⊢ False

tactic: apply (hc.trans (self_le_add_left _ a)).trans_lt
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
hc : ℵ₀ ≤ c
⊢ ℵ₀ < ℵ₀

tactic: rw [← h]
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
hc : ℵ₀ ≤ c
⊢ a + c < ℵ₀

tactic: apply add_lt_aleph0 ha hb
state_before: a b c : Cardinal
h : a + b = a + c
ha : a < ℵ₀
hb : b < ℵ₀
hc : ℵ₀ ≤ c
⊢ a + b < ℵ₀
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_of_le
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ ↑Fin.castSucc j
⊢ σ X (Fin.succ j) ≫ δ X (↑Fin.castSucc i) = δ X i ≫ σ X j

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_le H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ ↑Fin.castSucc j
⊢ X.map (SimplexCategory.σ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ (↑Fin.castSucc i)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
Theorem: isConformalMap_of_subsingleton
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

tactic: simp [Subsingleton.elim x 0]
state_before: R : Type u_2
M : Type u_1
N : Type u_3
G : Type ?u.204628
M' : Type ?u.204631
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Subsingleton M
f' : M →L[R] N
x : M
⊢ ‖↑0 x‖ = ‖x‖
Theorem: Polynomial.restriction_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rw [coeff_restriction', coeff_one, coeff_one]
state_before: R : Type u
S : Type ?u.77804
inst✝ : Ring R
i : ℕ
⊢ ↑(coeff (restriction 1) i) = ↑(coeff 1 i)

tactic: split_ifs <;> rfl
state_before: R : Type u
S : Type ?u.77804
inst✝ : Ring R
i : ℕ
⊢ (if 0 = i then 1 else 0) = ↑(if 0 = i then 1 else 0)
Theorem: Metric.frontier_cthickening_disjoint
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simpa
state_before: ι : Sort ?u.159481
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
A : Set α
r₁ r₂ : ℝ≥0
hr : r₁ ≠ r₂
⊢ ENNReal.ofReal ↑r₁ ≠ ENNReal.ofReal ↑r₂
Theorem: Nat.div_mul_div_le_div
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: simp [hm0]
state_before: m✝ n✝ k✝ l m n k : ℕ
hm0 : m = 0
⊢ m / k * n / m ≤ n / k

tactic: rw [mul_comm]
state_before: m✝ n✝ k✝ l m n k : ℕ
hm0 : ¬m = 0
⊢ m / k * n ≤ n * m / k

tactic: exact mul_div_le_mul_div_assoc _ _ _
state_before: m✝ n✝ k✝ l m n k : ℕ
hm0 : ¬m = 0
⊢ n * (m / k) ≤ n * m / k
Theorem: Equiv.removeNone_aux_inv
File: Mathlib/Logic/Equiv/Option.lean

tactic: cases h1 : e.symm (some (removeNone_aux e x)) <;> cases h2 : e (some x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x : α
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: rw [removeNone_aux_none _ h1]
state_before: case none.none
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x : α
h1 : ↑e.symm (some (removeNone_aux e x)) = none
h2 : ↑e (some x) = none
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: exact (e.eq_symm_apply.mpr h2).symm
state_before: case none.none
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x : α
h1 : ↑e.symm (some (removeNone_aux e x)) = none
h2 : ↑e (some x) = none
⊢ ↑e.symm none = some x

tactic: rw [removeNone_aux_some _ ⟨_, h2⟩] at h1
state_before: case none.some
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x : α
h1 : ↑e.symm (some (removeNone_aux e x)) = none
val✝ : β
h2 : ↑e (some x) = some val✝
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: simp at h1
state_before: case none.some
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x : α
h1 : ↑e.symm (↑e (some x)) = none
val✝ : β
h2 : ↑e (some x) = some val✝
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: rw [removeNone_aux_none _ h2] at h1
state_before: case some.none
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x val✝ : α
h1 : ↑e.symm (some (removeNone_aux e x)) = some val✝
h2 : ↑e (some x) = none
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: simp at h1
state_before: case some.none
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x val✝ : α
h1 : ↑e.symm (↑e none) = some val✝
h2 : ↑e (some x) = none
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: rw [removeNone_aux_some _ ⟨_, h1⟩]
state_before: case some.some
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x val✝¹ : α
h1 : ↑e.symm (some (removeNone_aux e x)) = some val✝¹
val✝ : β
h2 : ↑e (some x) = some val✝
⊢ some (removeNone_aux e.symm (removeNone_aux e x)) = some x

tactic: rw [removeNone_aux_some _ ⟨_, h2⟩]
state_before: case some.some
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x val✝¹ : α
h1 : ↑e.symm (some (removeNone_aux e x)) = some val✝¹
val✝ : β
h2 : ↑e (some x) = some val✝
⊢ ↑e.symm (some (removeNone_aux e x)) = some x

tactic: simp
state_before: case some.some
α : Type u_1
β : Type u_2
γ : Type ?u.3190
e : Option α ≃ Option β
x val✝¹ : α
h1 : ↑e.symm (some (removeNone_aux e x)) = some val✝¹
val✝ : β
h2 : ↑e (some x) = some val✝
⊢ ↑e.symm (↑e (some x)) = some x
Theorem: CategoryTheory.preimage_comp
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
inst✝¹ : Full F
inst✝ : Faithful F
X Y Z : C
f : F.obj X ⟶ F.obj Y
g : F.obj Y ⟶ F.obj Z
⊢ F.map (F.preimage (f ≫ g)) = F.map (F.preimage f ≫ F.preimage g)
Theorem: Submodule.IsPrincipal.mem_iff_generator_dvd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: simp only [mul_comm, smul_eq_mul]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
S : Ideal R
inst✝ : IsPrincipal S
x a : R
⊢ x = a • generator S ↔ x = generator S * a
Theorem: ContinuousMultilinearMap.toMultilinearMap_injective
File: Mathlib/Topology/Algebra/Module/Multilinear.lean

tactic: subst h
state_before: R : Type u
ι : Type v
n : ℕ
M : Fin (Nat.succ n) → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
inst✝¹⁸ : Semiring R
inst✝¹⁷ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹⁵ : (i : ι) → AddCommMonoid (M₁' i)
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹⁰ : (i : ι) → Module R (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁' i)
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : (i : Fin (Nat.succ n)) → TopologicalSpace (M i)
inst✝⁴ : (i : ι) → TopologicalSpace (M₁ i)
inst✝³ : (i : ι) → TopologicalSpace (M₁' i)
inst✝² : TopologicalSpace M₂
inst✝¹ : TopologicalSpace M₃
inst✝ : TopologicalSpace M₄
f✝ f' : ContinuousMultilinearMap R M₁ M₂
f : MultilinearMap R M₁ M₂
hf : Continuous f.toFun
g : MultilinearMap R M₁ M₂
hg : Continuous g.toFun
h : { toMultilinearMap := f, cont := hf }.toMultilinearMap = { toMultilinearMap := g, cont := hg }.toMultilinearMap
⊢ { toMultilinearMap := f, cont := hf } = { toMultilinearMap := g, cont := hg }

tactic: rfl
state_before: R : Type u
ι : Type v
n : ℕ
M : Fin (Nat.succ n) → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
inst✝¹⁸ : Semiring R
inst✝¹⁷ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹⁵ : (i : ι) → AddCommMonoid (M₁' i)
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹⁰ : (i : ι) → Module R (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁' i)
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : (i : Fin (Nat.succ n)) → TopologicalSpace (M i)
inst✝⁴ : (i : ι) → TopologicalSpace (M₁ i)
inst✝³ : (i : ι) → TopologicalSpace (M₁' i)
inst✝² : TopologicalSpace M₂
inst✝¹ : TopologicalSpace M₃
inst✝ : TopologicalSpace M₄
f✝ f' : ContinuousMultilinearMap R M₁ M₂
f : MultilinearMap R M₁ M₂
hf : Continuous f.toFun
hg : Continuous { toMultilinearMap := f, cont := hf }.toMultilinearMap.toFun
⊢ { toMultilinearMap := f, cont := hf } =
    { toMultilinearMap := { toMultilinearMap := f, cont := hf }.toMultilinearMap, cont := hg }
Theorem: SemiconjBy.zero_right
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

tactic: simp only [SemiconjBy, mul_zero, zero_mul]
state_before: α : Type ?u.23
M₀ : Type ?u.26
G₀ : Type u_1
M₀' : Type ?u.32
G₀' : Type ?u.35
F : Type ?u.38
F' : Type ?u.41
inst✝ : MulZeroClass G₀
a : G₀
⊢ SemiconjBy a 0 0
Theorem: Cardinal.power_le_max_power_one
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: by_cases ha : a = 0
state_before: α β : Type u
a b c : Cardinal
h : b ≤ c
⊢ a ^ b ≤ max (a ^ c) 1

tactic: simp [ha, zero_power_le]
state_before: case pos
α β : Type u
a b c : Cardinal
h : b ≤ c
ha : a = 0
⊢ a ^ b ≤ max (a ^ c) 1

tactic: exact (power_le_power_left ha h).trans (le_max_left _ _)
state_before: case neg
α β : Type u
a b c : Cardinal
h : b ≤ c
ha : ¬a = 0
⊢ a ^ b ≤ max (a ^ c) 1
Theorem: Finset.uIcc_injective_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [ext_iff] at h
state_before: ι : Type ?u.192881
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : (fun b => [[b, a]]) b = (fun b => [[b, a]]) c
⊢ b = c

tactic: exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
state_before: ι : Type ?u.192881
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : ∀ (a_1 : α), a_1 ∈ (fun b => [[b, a]]) b ↔ a_1 ∈ (fun b => [[b, a]]) c
⊢ b = c
Theorem: ModuleCat.MonoidalCategory.braiding_naturality
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Symmetric.lean

tactic: apply TensorProduct.ext'
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ Y₁ Y₂ : ModuleCat R
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ (f ⊗ g) ≫ (braiding Y₁ Y₂).hom = (braiding X₁ X₂).hom ≫ (g ⊗ f)

tactic: intro x y
state_before: case H
R : Type u
inst✝ : CommRing R
X₁ X₂ Y₁ Y₂ : ModuleCat R
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ ∀ (x : ↑X₁) (y : ↑X₂), ↑((f ⊗ g) ≫ (braiding Y₁ Y₂).hom) (x ⊗ₜ[R] y) = ↑((braiding X₁ X₂).hom ≫ (g ⊗ f)) (x ⊗ₜ[R] y)

tactic: rfl
state_before: case H
R : Type u
inst✝ : CommRing R
X₁ X₂ Y₁ Y₂ : ModuleCat R
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
x : ↑X₁
y : ↑X₂
⊢ ↑((f ⊗ g) ≫ (braiding Y₁ Y₂).hom) (x ⊗ₜ[R] y) = ↑((braiding X₁ X₂).hom ≫ (g ⊗ f)) (x ⊗ₜ[R] y)
Theorem: Polynomial.dickson_add_two
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: rw [dickson]
state_before: R : Type u_1
S : Type ?u.46134
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
⊢ dickson k a (n + 2) = X * dickson k a (n + 1) - ↑C a * dickson k a n
Theorem: IsROrC.smul_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [real_smul_eq_coe_mul, ofReal_mul_re]
state_before: K : Type u_1
E : Type ?u.2095993
inst✝ : IsROrC K
r : ℝ
z : K
⊢ ↑re (r • z) = r * ↑re z
Theorem: Stream'.WSeq.dropn_cons
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction n with
| zero => simp [drop]
| succ n n_ih =>
  simp [drop, ←n_ih]
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
n : ℕ
⊢ drop (cons a s) (n + 1) = drop s n

tactic: simp [drop]
state_before: case zero
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ drop (cons a s) (Nat.zero + 1) = drop s Nat.zero

tactic: simp [drop, ←n_ih]
state_before: case succ
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
n : ℕ
n_ih : drop (cons a s) (n + 1) = drop s n
⊢ drop (cons a s) (Nat.succ n + 1) = drop s (Nat.succ n)
Theorem: LatticeOrderedCommGroup.neg_eq_inv_inf_one
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [m_neg_part_def, ← inv_inj, inv_sup_eq_inv_inf_inv, inv_inv, inv_inv, inv_one]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ a⁻ = (a ⊓ 1)⁻¹
Theorem: RatFunc.ofFractionRing_mul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [Mul.mul, HMul.hMul, RatFunc.mul]
state_before: K : Type u
inst✝ : CommRing K
p q : FractionRing K[X]
⊢ { toFractionRing := p * q } = { toFractionRing := p } * { toFractionRing := q }
Theorem: CategoryTheory.Limits.Cotrident.coequalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: rw [← s.app_one (Classical.arbitrary J), Category.assoc, Category.assoc, h]
state_before: J : Type w
C : Type u
inst✝¹ : Category C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s : Cotrident f
W : C
k l : s.pt ⟶ W
h : π s ≫ k = π s ≫ l
⊢ s.ι.app zero ≫ k = s.ι.app zero ≫ l
Theorem: Sum.isRight_swap
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.23020
δ : Type ?u.23023
x : α ⊕ β
⊢ isRight (swap x) = isLeft x
Theorem: spectrum.zero_mem_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [mem_iff, map_zero, zero_sub, IsUnit.neg_iff]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
⊢ 0 ∈ σ a ↔ ¬IsUnit a
Theorem: PrimeMultiset.coePNat_nat
File: Mathlib/Data/PNat/Factors.lean

tactic: change (v.map (Coe.coe : Nat.Primes → ℕ+)).map Subtype.val = v.map Subtype.val
state_before: v : PrimeMultiset
⊢ Multiset.map PNat.val (toPNatMultiset v) = toNatMultiset v

tactic: rw [Multiset.map_map]
state_before: v : PrimeMultiset
⊢ Multiset.map Subtype.val (Multiset.map Coe.coe v) = Multiset.map Subtype.val v

tactic: congr
state_before: v : PrimeMultiset
⊢ Multiset.map (Subtype.val ∘ Coe.coe) v = Multiset.map Subtype.val v
Theorem: List.get?_reverse
File: Std/Data/List/Lemmas.lean

tactic: rw [Nat.add_sub_of_le (Nat.le_pred_of_lt h),
  Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) h)]
state_before: α : Type u_1
l : List α
i : Nat
h : i < length l
⊢ i + (length l - 1 - i) + 1 = length l
Theorem: Padic.AddValuation.map_zero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [addValuationDef, if_pos (Eq.refl _)]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ addValuationDef 0 = ⊤
Theorem: MeasureTheory.lintegral_iInf_ae
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type ?u.989121
γ : Type ?u.989124
δ : Type ?u.989127
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f (Nat.succ n) ≤ᵐ[μ] f n
h_fin : (∫⁻ (a : α), f 0 a ∂μ) ≠ ⊤
fn_le_f0 : (∫⁻ (a : α), ⨅ (n : ℕ), f n a ∂μ) ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : (⨅ (n : ℕ), ∫⁻ (a : α), f n a ∂μ) ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f (Nat.succ n) a ≤ f n a
n : ℕ
a : α
h : ∀ (n : ℕ), f (Nat.succ n) a ≤ f n a
⊢ f n a ≤ f 0 a
Theorem: Finset.centerMass_pair
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp only [centerMass, sum_pair hne, smul_add, (mul_smul _ _ _).symm, div_eq_inv_mul]
state_before: R : Type u_3
E : Type u_2
F : Type ?u.9139
ι : Type u_1
ι' : Type ?u.9145
α : Type ?u.9148
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hne : i ≠ j
⊢ centerMass {i, j} w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j