1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Prod.image_mk_segment_right
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rw [segment_eq_image₂, segment_eq_image₂, image_image]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
⊢ (fun y => (x, y)) '' [y₁-[𝕜]y₂] = [(x, y₁)-[𝕜](x, y₂)]
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
⊢ (fun x_1 => (x, x_1.1 • y₁ + x_1.2 • y₂)) '' {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1} =
    (fun p => p.1 • (x, y₁) + p.2 • (x, y₂)) '' {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1}

tactic: refine EqOn.image_eq fun a ha ↦ ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
⊢ (fun x_1 => (x, x_1.1 • y₁ + x_1.2 • y₂)) '' {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1} =
    (fun p => p.1 • (x, y₁) + p.2 • (x, y₂)) '' {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
a : 𝕜 × 𝕜
ha : a ∈ {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1}
⊢ (x, a.1 • y₁ + a.2 • y₂) = a.1 • (x, y₁) + a.2 • (x, y₂)

tactic: simp [Convex.combo_self ha.2.2]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
a : 𝕜 × 𝕜
ha : a ∈ {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1}
⊢ (x, a.1 • y₁ + a.2 • y₂) = a.1 • (x, y₁) + a.2 • (x, y₂)
state_after: no goals
Theorem: Real.cos_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [two_mul, cos_add]
state_before: ⊢ cos (2 * π) = 1
state_after: no goals
Theorem: Matrix.PosSemidef.zero
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: simp
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
⊢ ∀ (x : n → R), 0 ≤ star x ⬝ᵥ 0 *ᵥ x
state_after: no goals
Theorem: Multiset.eq_zero_of_forall_not_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [eq_nil_iff_forall_not_mem.mpr H]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
l : List α
H : ∀ (x : α), x ∉ Quot.mk Setoid.r l
⊢ Quot.mk Setoid.r l = 0
state_after: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
l : List α
H : ∀ (x : α), x ∉ Quot.mk Setoid.r l
⊢ Quot.mk Setoid.r [] = 0

tactic: rfl
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
l : List α
H : ∀ (x : α), x ∉ Quot.mk Setoid.r l
⊢ Quot.mk Setoid.r [] = 0
state_after: no goals
Theorem: div_le_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_le_iff_le_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ c ↔ a ≤ b * c
state_after: no goals
Theorem: Nat.prime_def_lt'
File: Mathlib/Data/Nat/Prime.lean

tactic: decide
state_before: n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : m < p → m ∣ p → m = 1
m2 : 2 ≤ m
l : m < p
d : m ∣ p
⊢ 1 < 2
state_after: no goals

tactic: rcases m with (_ | _ | m)
state_before: n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m → m < p → ¬m ∣ p
l : m < p
d : m ∣ p
⊢ m = 1
state_after: case zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 0 = 1

case succ.zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 + 1 → 0 + 1 < p → ¬0 + 1 ∣ p
l : 0 + 1 < p
d : 0 + 1 ∣ p
⊢ 0 + 1 = 1

case succ.succ
n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m + 1 + 1 → m + 1 + 1 < p → ¬m + 1 + 1 ∣ p
l : m + 1 + 1 < p
d : m + 1 + 1 ∣ p
⊢ m + 1 + 1 = 1

tactic: rw [eq_zero_of_zero_dvd d] at p2
state_before: case zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 0 = 1
state_after: case zero
n p : ℕ
p2 : 2 ≤ 0
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 0 = 1

tactic: revert p2
state_before: case zero
n p : ℕ
p2 : 2 ≤ 0
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 0 = 1
state_after: case zero
n p : ℕ
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 2 ≤ 0 → 0 = 1

tactic: decide
state_before: case zero
n p : ℕ
h : 2 ≤ 0 → 0 < p → ¬0 ∣ p
l : 0 < p
d : 0 ∣ p
⊢ 2 ≤ 0 → 0 = 1
state_after: no goals

tactic: rfl
state_before: case succ.zero
n p : ℕ
p2 : 2 ≤ p
h : 2 ≤ 0 + 1 → 0 + 1 < p → ¬0 + 1 ∣ p
l : 0 + 1 < p
d : 0 + 1 ∣ p
⊢ 0 + 1 = 1
state_after: no goals

tactic: exact (h le_add_self l).elim d
state_before: case succ.succ
n p : ℕ
p2 : 2 ≤ p
m : ℕ
h : 2 ≤ m + 1 + 1 → m + 1 + 1 < p → ¬m + 1 + 1 ∣ p
l : m + 1 + 1 < p
d : m + 1 + 1 ∣ p
⊢ m + 1 + 1 = 1
state_after: no goals
Theorem: PNat.Coprime.gcd_mul_left_cancel_right
File: Mathlib/Data/PNat/Prime.lean

tactic: intro h
state_before: m n k : ℕ+
⊢ k.Coprime m → m.gcd (k * n) = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime m
⊢ m.gcd (k * n) = m.gcd n

tactic: iterate 2 rw [gcd_comm]; symm;
state_before: m n k : ℕ+
h : k.Coprime m
⊢ m.gcd (k * n) = m.gcd n
state_after: m n k : ℕ+
h : k.Coprime m
⊢ (k * n).gcd m = n.gcd m

tactic: apply Coprime.gcd_mul_left_cancel _ h
state_before: m n k : ℕ+
h : k.Coprime m
⊢ (k * n).gcd m = n.gcd m
state_after: no goals

tactic: rw [gcd_comm]
state_before: m n k : ℕ+
h : k.Coprime m
⊢ m.gcd n = (k * n).gcd m
state_after: m n k : ℕ+
h : k.Coprime m
⊢ n.gcd m = (k * n).gcd m

tactic: symm
state_before: m n k : ℕ+
h : k.Coprime m
⊢ n.gcd m = (k * n).gcd m
state_after: m n k : ℕ+
h : k.Coprime m
⊢ (k * n).gcd m = n.gcd m
Theorem: Matrix.BlockTriangular.sub
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: simp_rw [Matrix.sub_apply, hM h, hN h, sub_zero]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝¹ : CommRing R
M N : Matrix m m R
b : m → α
inst✝ : LT α
hM : M.BlockTriangular b
hN : N.BlockTriangular b
i j : m
h : b j < b i
⊢ (M - N) i j = 0
state_after: no goals
Theorem: preNormEDS'_three
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: rw [preNormEDS']
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS' b c d 3 = c
state_after: no goals
Theorem: SimpleGraph.adjMatrix_dotProduct
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [neighborFinset_eq_filter, dotProduct, sum_filter]
state_before: V : Type u_1
α : Type u_2
β : Type u_3
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype V
inst✝ : NonAssocSemiring α
v : V
vec : V → α
⊢ adjMatrix α G v ⬝ᵥ vec = ∑ u ∈ G.neighborFinset v, vec u
state_after: no goals
Theorem: Nat.binomial_spec
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simpa [Finset.sum_pair hab, Finset.prod_pair hab] using multinomial_spec {a, b} f
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
hab : a ≠ b
⊢ (f a)! * (f b)! * multinomial {a, b} f = (f a + f b)!
state_after: no goals
Theorem: Lagrange.basis_pair_right
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [pair_comm]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {i, j} v j = basisDivisor (v j) (v i)
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {j, i} v j = basisDivisor (v j) (v i)

tactic: exact basis_pair_left hij.symm
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {j, i} v j = basisDivisor (v j) (v i)
state_after: no goals
Theorem: Basis.orientation_map
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: simp_rw [Basis.orientation, Orientation.map_apply, Basis.det_map']
state_before: R : Type u_1
inst✝⁸ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R M
inst✝⁴ : Module R N
ι : Type u_4
ι' : Type u_5
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
e : Basis ι R M
f : M ≃ₗ[R] N
⊢ (e.map f).orientation = (Orientation.map ι f) e.orientation
state_after: no goals
Theorem: CircleDeg1Lift.translate_zpow
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [← zsmul_eq_mul, ofAdd_zsmul, MonoidHom.map_zpow]
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℤ
⊢ translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd (↑n * x))
state_after: no goals
Theorem: tendsto_comp_coe_Ioo_atTop
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: rw [← map_coe_Ioo_atTop h, tendsto_map'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f (𝓝[<] b) l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
state_after: no goals
Theorem: ConcaveOn.min_le_of_mem_Icc
File: Mathlib/Analysis/Convex/Jensen.lean

tactic: rw [← segment_eq_Icc (hz.1.trans hz.2)] at hf hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f✝ : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
x✝ y✝ z✝ : E
f : 𝕜 → β
x y z : 𝕜
hf : ConcaveOn 𝕜 (Set.Icc x y) f
hz : z ∈ Set.Icc x y
⊢ min (f x) (f y) ≤ f z
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f✝ : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
x✝ y✝ z✝ : E
f : 𝕜 → β
x y z : 𝕜
hf : ConcaveOn 𝕜 [x-[𝕜]y] f
hz : z ∈ [x-[𝕜]y]
⊢ min (f x) (f y) ≤ f z

tactic: exact hf.min_le_of_mem_segment hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f✝ : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
x✝ y✝ z✝ : E
f : 𝕜 → β
x y z : 𝕜
hf : ConcaveOn 𝕜 [x-[𝕜]y] f
hz : z ∈ [x-[𝕜]y]
⊢ min (f x) (f y) ≤ f z
state_after: no goals
Theorem: Vector.reverse_reverse
File: Mathlib/Data/Vector/Basic.lean

tactic: cases v
state_before: n : ℕ
α : Type u_1
v : Vector α n
⊢ v.reverse.reverse = v
state_after: case mk
n : ℕ
α : Type u_1
val✝ : List α
property✝ : val✝.length = n
⊢ (reverse ⟨val✝, property✝⟩).reverse = ⟨val✝, property✝⟩

tactic: simp [Vector.reverse]
state_before: case mk
n : ℕ
α : Type u_1
val✝ : List α
property✝ : val✝.length = n
⊢ (reverse ⟨val✝, property✝⟩).reverse = ⟨val✝, property✝⟩
state_after: no goals
Theorem: Subgroup.IsComplement.equiv_snd_eq_one_of_mem_of_one_mem
File: Mathlib/GroupTheory/Complement.lean

tactic: ext
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ (hST.equiv g).2 = ⟨1, h1⟩
state_after: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ ↑(hST.equiv g).2 = ↑⟨1, h1⟩

tactic: rw [equiv_snd_eq_inv_mul, equiv_fst_eq_self_of_mem_of_one_mem _ h1 hg, inv_mul_self]
state_before: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ ↑(hST.equiv g).2 = ↑⟨1, h1⟩
state_after: no goals
Theorem: ENNReal.div_lt_of_lt_mul
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rwa [div_eq_mul_inv, inv_inv]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a < b * c
⊢ a < b / c⁻¹
state_after: no goals
Theorem: Polynomial.coeff_one
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simp_rw [eq_comm (a := n) (b := 0)]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ coeff 1 n = if n = 0 then 1 else 0
state_after: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ coeff 1 n = if 0 = n then 1 else 0

tactic: exact coeff_monomial
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ coeff 1 n = if 0 = n then 1 else 0
state_after: no goals
Theorem: CategoryTheory.Limits.MonoCoprod.mono_inl_iff
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

tactic: suffices
  ∀ (c₁ c₂ : BinaryCofan A B) (_ : IsColimit c₁) (_ : IsColimit c₂) (_ : Mono c₁.inl),
    Mono c₂.inl
  by exact ⟨fun h₁ => this _ _ hc₁ hc₂ h₁, fun h₂ => this _ _ hc₂ hc₁ h₂⟩
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ Mono c₁.inl ↔ Mono c₂.inl
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ ∀ (c₁ c₂ : BinaryCofan A B), IsColimit c₁ → IsColimit c₂ → Mono c₁.inl → Mono c₂.inl

tactic: intro c₁ c₂ hc₁ hc₂
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ ∀ (c₁ c₂ : BinaryCofan A B), IsColimit c₁ → IsColimit c₂ → Mono c₁.inl → Mono c₂.inl
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ Mono c₁.inl → Mono c₂.inl

tactic: intro
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ Mono c₁.inl → Mono c₂.inl
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
x✝ : Mono c₁.inl
⊢ Mono c₂.inl

tactic: simpa only [IsColimit.comp_coconePointUniqueUpToIso_hom] using
  mono_comp c₁.inl (hc₁.coconePointUniqueUpToIso hc₂).hom
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
x✝ : Mono c₁.inl
⊢ Mono c₂.inl
state_after: no goals

tactic: exact ⟨fun h₁ => this _ _ hc₁ hc₂ h₁, fun h₂ => this _ _ hc₂ hc₁ h₂⟩
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
this : ∀ (c₁ c₂ : BinaryCofan A B), IsColimit c₁ → IsColimit c₂ → Mono c₁.inl → Mono c₂.inl
⊢ Mono c₁.inl ↔ Mono c₂.inl
state_after: no goals
Theorem: OrderMonoidWithZeroHom.toMonoidWithZeroHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert DFunLike.ext_iff.1 h using 0
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f✝ g✝ f g : α →*₀o β
h : f.toMonoidWithZeroHom = g.toMonoidWithZeroHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
Theorem: Commute.of_map
File: Mathlib/Algebra/Group/Commute/Hom.lean

tactic: simpa only [map_mul] using h.eq
state_before: F : Type u_1
M : Type u_2
N : Type u_3
inst✝³ : Mul M
inst✝² : Mul N
a x y : M
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
f : F
hf : Function.Injective ⇑f
h : Commute (f x) (f y)
⊢ f (x * y) = f (y * x)
state_after: no goals
Theorem: IsPrimitiveRoot.autToPow_eq_ModularCyclotomicCharacter
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

tactic: ext
state_before: L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (autToPow R hμ) g = (ModularCyclotomicCharacter L ⋯) ↑g
state_after: case a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ ↑((autToPow R hμ) g) = ↑((ModularCyclotomicCharacter L ⋯) ↑g)

tactic: apply ZMod.val_injective
state_before: case a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ ↑((autToPow R hμ) g) = ↑((ModularCyclotomicCharacter L ⋯) ↑g)
state_after: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (↑((autToPow R hμ) g)).val = (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val

tactic: apply hμ.pow_inj (ZMod.val_lt _) (ZMod.val_lt _)
state_before: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ (↑((autToPow R hμ) g)).val = (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
state_after: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ μ ^ (↑((autToPow R hμ) g)).val = μ ^ (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val

tactic: simpa [autToPow_spec R hμ g, ModularCyclotomicCharacter', ModularCyclotomicCharacter,
  ZMod.ringEquivCongr_val] using ModularCyclotomicCharacter.toFun_spec'' g hμ
state_before: case a.a
L : Type u
inst✝³ : CommRing L
inst✝² : IsDomain L
n✝ n : ℕ+
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Algebra R L
μ : L
hμ : IsPrimitiveRoot μ ↑n
g : L ≃ₐ[R] L
⊢ μ ^ (↑((autToPow R hμ) g)).val = μ ^ (↑((ModularCyclotomicCharacter L ⋯) ↑g)).val
state_after: no goals
Theorem: zpow_eq_zpow_emod'
File: Mathlib/Algebra/Group/Basic.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n✝ : ℤ
x : G
m : ℤ
n : ℕ
h : x ^ n = 1
⊢ x ^ ↑n = 1
state_after: no goals
Theorem: CategoryTheory.Adjunction.right_triangle
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
⊢ whiskerLeft G adj.unit ≫ whiskerRight adj.counit G = 𝟙 (G ⋙ 𝟭 C)
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ (whiskerLeft G adj.unit ≫ whiskerRight adj.counit G).app x✝ = (𝟙 (G ⋙ 𝟭 C)).app x✝

tactic: dsimp
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ (whiskerLeft G adj.unit ≫ whiskerRight adj.counit G).app x✝ = (𝟙 (G ⋙ 𝟭 C)).app x✝
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ adj.unit.app (G.obj x✝) ≫ G.map (adj.counit.app x✝) = 𝟙 (G.obj x✝)

tactic: erw [← adj.homEquiv_unit, ← Equiv.eq_symm_apply, adj.homEquiv_counit]
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ adj.unit.app (G.obj x✝) ≫ G.map (adj.counit.app x✝) = 𝟙 (G.obj x✝)
state_after: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ adj.counit.app x✝ = F.map (𝟙 (G.obj x✝)) ≫ adj.counit.app x✝

tactic: simp
state_before: case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' x✝ : D
⊢ adj.counit.app x✝ = F.map (𝟙 (G.obj x✝)) ≫ adj.counit.app x✝
state_after: no goals
Theorem: ZNum.le_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← not_lt]
state_before: α : Type u_1
m n : ZNum
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: α : Type u_1
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n

tactic: exact not_congr lt_to_int
state_before: α : Type u_1
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n
state_after: no goals
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.{v, u} C
X Y : C
D : Type u₂
inst✝⁵ : Category.{w, u₂} 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
state_after: no goals
Theorem: FreeAlgebra.quot_mk_eq_ι
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [ι_def]
state_before: R : Type u_1
inst✝ : CommSemiring R
X : Type u_2
m : X
⊢ Quot.mk (Rel R X) (Pre.of m) = ι R m
state_after: no goals
Theorem: Asymptotics.superpolynomialDecay_const_mul_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp [← mul_assoc, inv_mul_cancel hc0]
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : Field β
inst✝ : ContinuousMul β
c : β
hc0 : c ≠ 0
h : SuperpolynomialDecay l k fun n => c * f n
x : α
⊢ c⁻¹ * (c * f x) = f x
state_after: no goals
Theorem: mul_singleton_mem_nhds_of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa only [one_mul] using mul_singleton_mem_nhds a h
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
a : α
h : s ∈ 𝓝 1
⊢ s * {a} ∈ 𝓝 a
state_after: no goals
Theorem: Multiset.card_antidiagonal
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: have := card_powerset s
state_before: α : Type u_1
β : Type u_2
s : Multiset α
⊢ card s.antidiagonal = 2 ^ card s
state_after: α : Type u_1
β : Type u_2
s : Multiset α
this : card s.powerset = 2 ^ card s
⊢ card s.antidiagonal = 2 ^ card s

tactic: rwa [← antidiagonal_map_fst, card_map] at this
state_before: α : Type u_1
β : Type u_2
s : Multiset α
this : card s.powerset = 2 ^ card s
⊢ card s.antidiagonal = 2 ^ card s
state_after: no goals