1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.rightDistributor_ext₂_right
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: apply (cancel_mono (α_ _ _ _).hom).mp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z
w : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f j ▷ Y ▷ Z
⊢ g = h
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z
w : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f j ▷ Y ▷ Z
⊢ g ≫ (α_ (⨁ f) Y Z).hom = h ≫ (α_ (⨁ f) Y Z).hom

tactic: ext
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z
w : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f j ▷ Y ▷ Z
⊢ g ≫ (α_ (⨁ f) Y Z).hom = h ≫ (α_ (⨁ f) Y Z).hom
state_after: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z
w : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f j ▷ Y ▷ Z
j✝ : J
⊢ (g ≫ (α_ (⨁ f) Y Z).hom) ≫ biproduct.π f j✝ ▷ (Y ⊗ Z) = (h ≫ (α_ (⨁ f) Y Z).hom) ≫ biproduct.π f j✝ ▷ (Y ⊗ Z)

tactic: simp [w]
state_before: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : X ⟶ ((⨁ f) ⊗ Y) ⊗ Z
w : ∀ (j : J), g ≫ biproduct.π f j ▷ Y ▷ Z = h ≫ biproduct.π f j ▷ Y ▷ Z
j✝ : J
⊢ (g ≫ (α_ (⨁ f) Y Z).hom) ≫ biproduct.π f j✝ ▷ (Y ⊗ Z) = (h ≫ (α_ (⨁ f) Y Z).hom) ≫ biproduct.π f j✝ ▷ (Y ⊗ Z)
state_after: no goals
Theorem: WeierstrassCurve.Affine.evalEval_polynomialX_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp only [evalEval_polynomialX, zero_add, zero_sub, mul_zero, zero_pow <| Nat.succ_ne_zero _]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ evalEval 0 0 W.polynomialX = -W.a₄
state_after: no goals
Theorem: Function.Injective.sOppSide_map_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: simp_rw [SOppSide, hf.wOppSide_map_iff, mem_map_iff_mem_of_injective hf]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
hf : Function.Injective ⇑f
⊢ (map f s).SOppSide (f x) (f y) ↔ s.SOppSide x y
state_after: no goals
Theorem: CliffordAlgebra.contractRight_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: simpa only [map_one] using contractRight_algebraMap Q d 1
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
⊢ (contractRight 1) d = 0
state_after: no goals
Theorem: lineDifferentiableAt_smul_iff
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simpa [smul_smul, inv_mul_cancel hc] using h.smul (c ⁻¹)
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f : E → F
s : Set E
x v : E
f' : F
c : 𝕜
hc : c ≠ 0
h : LineDifferentiableAt 𝕜 f x (c • v)
⊢ LineDifferentiableAt 𝕜 f x v
state_after: no goals
Theorem: SetTheory.PGame.neg_fuzzy_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
state_before: xl xr : Type u
x y : PGame
⊢ -x ‖ y ↔ x ‖ -y
state_after: no goals
Theorem: NFA.toεNFA_εClosure
File: Mathlib/Computability/EpsilonNFA.lean

tactic: ext a
state_before: α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a : α
M : NFA α σ
S : Set σ
⊢ M.toεNFA.εClosure S = S
state_after: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ M.toεNFA.εClosure S ↔ a ∈ S

tactic: refine ⟨?_, εNFA.εClosure.base _⟩
state_before: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ M.toεNFA.εClosure S ↔ a ∈ S
state_after: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ M.toεNFA.εClosure S → a ∈ S

tactic: rintro (⟨_, h⟩ | ⟨_, _, h, _⟩)
state_before: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ M.toεNFA.εClosure S → a ∈ S
state_after: case h.base
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
h : a ∈ S
⊢ a ∈ S

case h.step
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝¹ : α
M : NFA α σ
S : Set σ
a s✝ : σ
a✝ : M.toεNFA.εClosure S s✝
h : a ∈ M.toεNFA.step s✝ none
⊢ a ∈ S

tactic: exact h
state_before: case h.base
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
h : a ∈ S
⊢ a ∈ S
state_after: no goals

tactic: cases h
state_before: case h.step
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝¹ : α
M : NFA α σ
S : Set σ
a s✝ : σ
a✝ : M.toεNFA.εClosure S s✝
h : a ∈ M.toεNFA.step s✝ none
⊢ a ∈ S
state_after: no goals
Theorem: CategoryTheory.Limits.HasColimit.isoOfEquivalence_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp [HasColimit.isoOfEquivalence, IsColimit.coconePointsIsoOfEquivalence_inv]
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasColimit F
G : K ⥤ C
inst✝ : HasColimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
k : K
⊢ colimit.ι G k ≫ (isoOfEquivalence e w).inv =
    G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ colimit.ι F (e.inverse.obj k)
state_after: no goals
Theorem: Finset.Icc_eq_singleton_iff
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_eq_singleton, coe_Icc, Set.Icc_eq_singleton_iff]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Icc a b = {c} ↔ a = c ∧ b = c
state_after: no goals
Theorem: Matrix.stdBasisMatrix_zero
File: Mathlib/Data/Matrix/Basis.lean

tactic: unfold stdBasisMatrix
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
⊢ stdBasisMatrix i j 0 = 0
state_after: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
⊢ (fun i' j' => if i = i' ∧ j = j' then 0 else 0) = 0

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
⊢ (fun i' j' => if i = i' ∧ j = j' then 0 else 0) = 0
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
i✝ : m
j✝ : n
⊢ (if i = i✝ ∧ j = j✝ then 0 else 0) = 0 i✝ j✝

tactic: simp
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
i✝ : m
j✝ : n
⊢ (if i = i✝ ∧ j = j✝ then 0 else 0) = 0 i✝ j✝
state_after: no goals
Theorem: div_lt_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a✝ b✝ c d a b : α
⊢ a / b < a ↔ 1 < b
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.iff_of_iso
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

tactic: dsimp [IsInvertedBy]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
⊢ W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
⊢ (∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f → IsIso (F₁.map f)) ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f → IsIso (F₂.map f)

tactic: simp only [NatIso.isIso_map_iff e]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₁ F₂ : C ⥤ D
e : F₁ ≅ F₂
⊢ (∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f → IsIso (F₁.map f)) ↔ ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f → IsIso (F₂.map f)
state_after: no goals
Theorem: cauchySeq_of_dist_le_of_summable
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

tactic: lift d to ℕ → ℝ≥0 using fun n ↦ dist_nonneg.trans (hf n)
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ d n
hd : Summable d
⊢ CauchySeq f
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ CauchySeq f

tactic: apply cauchySeq_of_edist_le_of_summable d (α := α) (f := f)
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ CauchySeq f
state_after: case intro.hf
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)

case intro.hd
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ Summable d

tactic: exact_mod_cast hf
state_before: case intro.hf
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)
state_after: no goals

tactic: exact_mod_cast hd
state_before: case intro.hd
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), dist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable fun i => ↑(d i)
⊢ Summable d
state_after: no goals
Theorem: binary_relation_sInf_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sInf_apply]
state_before: α✝ : Type u_1
β✝ : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
β : Type u_10
s : Set (α → β → Prop)
a : α
b : β
⊢ sInf s a b ↔ ∀ r ∈ s, r a b
state_after: α✝ : Type u_1
β✝ : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
β : Type u_10
s : Set (α → β → Prop)
a : α
b : β
⊢ (⨅ f, ↑f a) b ↔ ∀ r ∈ s, r a b

tactic: simp [← eq_iff_iff]
state_before: α✝ : Type u_1
β✝ : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
α : Type u_9
β : Type u_10
s : Set (α → β → Prop)
a : α
b : β
⊢ (⨅ f, ↑f a) b ↔ ∀ r ∈ s, r a b
state_after: no goals
Theorem: mul_nonpos_iff_pos_imp_nonpos
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [← neg_nonneg, ← mul_neg, mul_nonneg_iff_pos_imp_nonneg (α := α)]
state_before: α : Type u
β : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ a * b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
state_after: α : Type u
β : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ (0 < a → 0 ≤ -b) ∧ (0 < -b → 0 ≤ a) ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)

tactic: simp only [neg_pos, neg_nonneg]
state_before: α : Type u
β : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ (0 < a → 0 ≤ -b) ∧ (0 < -b → 0 ≤ a) ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
state_after: no goals
Theorem: SatisfiesM_ReaderT_eq
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

tactic: exact ⟨fun eq _ => eq ▸ rfl, funext⟩
state_before: m : Type u_1 → Type u_2
ρ α✝ : Type u_1
p : α✝ → Prop
x : ReaderT ρ m α✝
inst✝ : Monad m
a : ReaderT ρ m { a // p a }
⊢ Subtype.val <$> a = x ↔ ∀ (x_1 : ρ), Subtype.val <$> a x_1 = x x_1
state_after: no goals
Theorem: toIcoDiv_apply_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp [hp]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a + p - 1 • p ∈ Set.Ico a (a + p)
state_after: no goals
Theorem: CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [colimitCurrySwapCompColimIsoColimitCurryCompColim]
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫ (colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
        ((colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv ≫
            (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
          (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j

tactic: slice_lhs 1 3 => simp only []
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
        ((colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv ≫
            (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
          (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ ((colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
          colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
            (colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv) ≫
        (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
      (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j

tactic: simp
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ ((colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
          colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
            (colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv) ≫
        (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
      (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: no goals
Theorem: IsCoprime.mul_add_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (z * x + y)
state_after: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + z * x)

tactic: exact h.add_mul_right_right z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + z * x)
state_after: no goals
Theorem: Basis.smul_repr
File: Mathlib/RingTheory/AlgebraTower.lean

tactic: simp [Basis.smul]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
ι : Type v₁
ι' : Type w₁
b : Basis ι R S
c : Basis ι' S A
x : A
ij : ι × ι'
⊢ ((b.smul c).repr x) ij = (b.repr ((c.repr x) ij.2)) ij.1
state_after: no goals
Theorem: Function.extend_mul
File: Mathlib/Algebra/Group/Pi/Basic.lean

tactic: classical
funext x
simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂
state_after: no goals

tactic: funext x
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂
state_after: case h
I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
x : β
⊢ extend f (g₁ * g₂) (e₁ * e₂) x = (extend f g₁ e₁ * extend f g₂ e₂) x

tactic: simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
state_before: case h
I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
x : β
⊢ extend f (g₁ * g₂) (e₁ * e₂) x = (extend f g₁ e₁ * extend f g₂ e₂) x
state_after: no goals
Theorem: AddLECancellable.tsub_lt_self
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine tsub_le_self.lt_of_ne fun h => ?_
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : 0 < a
h₂ : 0 < b
⊢ a - b < a
state_after: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : 0 < a
h₂ : 0 < b
h : a - b = a
⊢ False

tactic: rw [← h, tsub_pos_iff_lt] at h₁
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : 0 < a
h₂ : 0 < b
h : a - b = a
⊢ False
state_after: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : b < a
h₂ : 0 < b
h : a - b = a
⊢ False

tactic: exact h₂.not_le (ha.add_le_iff_nonpos_left.1 <| add_le_of_le_tsub_left_of_le h₁.le h.ge)
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h₁ : b < a
h₂ : 0 < b
h : a - b = a
⊢ False
state_after: no goals
Theorem: Submodule.linear_proj_add_linearProjOfIsCompl_eq_self
File: Mathlib/LinearAlgebra/Projection.lean

tactic: dsimp only [linearProjOfIsCompl]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑((p.linearProjOfIsCompl q hpq) x) + ↑((q.linearProjOfIsCompl p ⋯) x) = x
state_after: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑((LinearMap.fst R ↥p ↥q ∘ₗ ↑(p.prodEquivOfIsCompl q hpq).symm) x) +
      ↑((LinearMap.fst R ↥q ↥p ∘ₗ ↑(q.prodEquivOfIsCompl p ⋯).symm) x) =
    x

tactic: rw [← prodComm_trans_prodEquivOfIsCompl _ _ hpq]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑((LinearMap.fst R ↥p ↥q ∘ₗ ↑(p.prodEquivOfIsCompl q hpq).symm) x) +
      ↑((LinearMap.fst R ↥q ↥p ∘ₗ ↑(q.prodEquivOfIsCompl p ⋯).symm) x) =
    x
state_after: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑((LinearMap.fst R ↥p ↥q ∘ₗ ↑(p.prodEquivOfIsCompl q hpq).symm) x) +
      ↑((LinearMap.fst R ↥q ↥p ∘ₗ ↑(LinearEquiv.prodComm R ↥q ↥p ≪≫ₗ p.prodEquivOfIsCompl q hpq).symm) x) =
    x

tactic: exact (prodEquivOfIsCompl _ _ hpq).apply_symm_apply x
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
hpq : IsCompl p q
x : E
⊢ ↑((LinearMap.fst R ↥p ↥q ∘ₗ ↑(p.prodEquivOfIsCompl q hpq).symm) x) +
      ↑((LinearMap.fst R ↥q ↥p ∘ₗ ↑(LinearEquiv.prodComm R ↥q ↥p ≪≫ₗ p.prodEquivOfIsCompl q hpq).symm) x) =
    x
state_after: no goals
Theorem: collinear_iff_not_affineIndependent
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_iff_finrank_le_one,
  finrank_vectorSpan_le_iff_not_affineIndependent k p (Fintype.card_fin 3)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
⊢ Collinear k (Set.range p) ↔ ¬AffineIndependent k p
state_after: no goals
Theorem: Fin.pred_succAbove
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [succAbove_of_le_castSucc _ _ h, pred_succ]
state_before: n m : ℕ
p : Fin (n + 1)
i j x : Fin n
y : Fin (n + 1)
h : y ≤ x.castSucc
h' : optParam (y.succAbove x ≠ 0) ⋯
⊢ (y.succAbove x).pred h' = x
state_after: no goals