tasksource/leandojo huggingface dataset:
Theorem: le_isGLB_iff
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [h.lowerBounds_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
h : IsGLB s a
⊢ b ≤ a ↔ b ∈ lowerBounds s

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
h : IsGLB s a
⊢ b ≤ a ↔ b ∈ Iic a
Theorem: CauSeq.mul_equiv_mul
File: Mathlib/Data/Real/CauSeq.lean

tactic: change LimZero (f1 * g1 - f2 * g2)
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 ≈ f2 * g2

tactic: convert add_limZero (mul_limZero_left g1 hf) (mul_limZero_right f2 hg) using 1
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ LimZero (f1 * g1 - f2 * g2)

tactic: rw [mul_sub, sub_mul]
state_before: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = (f1 - f2) * g1 + f2 * (g1 - g2)

tactic: exact (sub_add_sub_cancel (f1*g1) (f2*g1) (f2*g2)).symm
state_before: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = f1 * g1 - f2 * g1 + (f2 * g1 - f2 * g2)
Theorem: CategoryTheory.Iso.hom_eq_inv
File: Mathlib/CategoryTheory/Iso.lean

tactic: erw [inv_eq_inv α.symm β, eq_comm]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
β : Y ≅ X
⊢ α.hom = β.inv ↔ β.hom = α.inv

tactic: rfl
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
β : Y ≅ X
⊢ β.hom = α.symm.hom ↔ β.hom = α.inv
Theorem: Finpartition.nonUniforms_bot
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: rw [eq_empty_iff_forall_not_mem]
state_before: α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
⊢ nonUniforms ⊥ G ε = ∅

tactic: rintro ⟨u, v⟩
state_before: α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
⊢ ∀ (x : Finset α × Finset α), ¬x ∈ nonUniforms ⊥ G ε

tactic: simp only [Finpartition.mk_mem_nonUniforms_iff, Finpartition.parts_bot, mem_map, not_and,
  Classical.not_not, exists_imp]
state_before: case mk
α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
⊢ ¬(u, v) ∈ nonUniforms ⊥ G ε

tactic: dsimp
state_before: case mk
α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
⊢ ∀ (x : α),
    x ∈ A ∧ ↑{ toFun := singleton, inj' := (_ : Function.Injective singleton) } x = u →
      ∀ (x : α),
        x ∈ A ∧ ↑{ toFun := singleton, inj' := (_ : Function.Injective singleton) } x = v →
          u ≠ v → SimpleGraph.IsUniform G ε u v

tactic: rintro x ⟨_,xu⟩  y ⟨_,yv⟩ _
state_before: case mk
α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
⊢ ∀ (x : α), x ∈ A ∧ {x} = u → ∀ (x : α), x ∈ A ∧ {x} = v → ¬u = v → SimpleGraph.IsUniform G ε u v

tactic: rw [←xu, ←yv]
state_before: case mk.intro.intro
α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
x : α
left✝¹ : x ∈ A
xu : {x} = u
y : α
left✝ : y ∈ A
yv : {y} = v
a✝ : ¬u = v
⊢ SimpleGraph.IsUniform G ε u v

tactic: exact G.isUniform_singleton hε
state_before: case mk.intro.intro
α : Type u_2
𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hε : 0 < ε
u v : Finset α
x : α
left✝¹ : x ∈ A
xu : {x} = u
y : α
left✝ : y ∈ A
yv : {y} = v
a✝ : ¬u = v
⊢ SimpleGraph.IsUniform G ε {x} {y}
Theorem: Odd.strictMono_pow
File: Mathlib/Algebra/Parity.lean

tactic: cases' hn with k hk
state_before: F : Type ?u.114094
α : Type ?u.114097
β : Type ?u.114100
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hn : Odd n
⊢ StrictMono fun a => a ^ n

tactic: simpa only [hk, two_mul] using strictMono_pow_bit1 _
state_before: case intro
F : Type ?u.114094
α : Type ?u.114097
β : Type ?u.114100
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n k : ℕ
hk : n = 2 * k + 1
⊢ StrictMono fun a => a ^ n
Theorem: self_sub_toIocMod
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod, sub_sub_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ b - toIocMod hp a b = toIocDiv hp a b • p
Theorem: Polynomial.taylor_monomial
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: simp [taylor_apply]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
i : ℕ
k : R
⊢ ↑(taylor r) (↑(monomial i) k) = ↑C k * (X + ↑C r) ^ i
Theorem: isClosed_compl_iff
File: Mathlib/Topology/Basic.lean

tactic: rw [← isOpen_compl_iff, compl_compl]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ IsClosed (sᶜ) ↔ IsOpen s
Theorem: integrableOn_Icc_iff_integrableOn_Ioo'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [integrableOn_Icc_iff_integrableOn_Ioc' ha, integrableOn_Ioc_iff_integrableOn_Ioo' hb]
state_before: α : Type u_1
β : Type ?u.3533131
E : Type u_2
F : Type ?u.3533137
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
ha : ↑↑μ {a} ≠ ⊤
hb : ↑↑μ {b} ≠ ⊤
⊢ IntegrableOn f (Icc a b) ↔ IntegrableOn f (Ioo a b)
Theorem: Nat.gcd_mul_right_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: simp [add_comm _ n]
state_before: m n k : ℕ
⊢ gcd m (k * m + n) = gcd m n
Theorem: eq_inv_mul_iff_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, mul_inv_cancel_left]
state_before: α : Type ?u.54481
β : Type ?u.54484
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = b⁻¹ * c
⊢ b * a = c

tactic: rw [← h, inv_mul_cancel_left]
state_before: α : Type ?u.54481
β : Type ?u.54484
G : Type u_1
inst✝ : Group G
a b c d : G
h : b * a = c
⊢ a = b⁻¹ * c
Theorem: AlgebraicTopology.DoldKan.map_PInfty_f
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: simp only [PInfty_f, map_P]
state_before: C : Type u_4
inst✝⁴ : Category C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_1
inst✝² : Category D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : Functor.Additive G
X : SimplicialObject C
n : ℕ
⊢ HomologicalComplex.Hom.f PInfty n = G.map (HomologicalComplex.Hom.f PInfty n)
Theorem: RingQuot.pow_quot
File: Mathlib/Algebra/RingQuot.lean

tactic: show npow r _ _ = _
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
a : R
n : ℕ
⊢ { toQuot := Quot.mk (Rel r) a } ^ n = { toQuot := Quot.mk (Rel r) (a ^ n) }

tactic: rw [npow_def]
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
a : R
n : ℕ
⊢ RingQuot.npow r n { toQuot := Quot.mk (Rel r) a } = { toQuot := Quot.mk (Rel r) (a ^ n) }
Theorem: Nat.add_left_cancel
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction n with
| zero => simp; intros; assumption
| succ n ih => simp [succ_add]; intro h; apply ih h
state_before: n m k : Nat
⊢ n + m = n + k → m = k

tactic: simp
state_before: case zero
m k : Nat
⊢ zero + m = zero + k → m = k

tactic: intros
state_before: case zero
m k : Nat
⊢ m = k → m = k

tactic: assumption
state_before: case zero
m k : Nat
a✝ : m = k
⊢ m = k

tactic: simp [succ_add]
state_before: case succ
m k n : Nat
ih : n + m = n + k → m = k
⊢ succ n + m = succ n + k → m = k

tactic: intro h
state_before: case succ
m k n : Nat
ih : n + m = n + k → m = k
⊢ n + m = n + k → m = k

tactic: apply ih h
state_before: case succ
m k n : Nat
ih : n + m = n + k → m = k
h : n + m = n + k
⊢ m = k
Theorem: CategoryTheory.NatIso.inv_map_inv_app
File: Mathlib/CategoryTheory/NatIso.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F✝ G : C ⥤ D
X✝ Y✝ : C
F : C ⥤ D ⥤ E
X Y : C
e : X ≅ Y
Z : D
⊢ inv ((F.map e.inv).app Z) = (F.map e.hom).app Z
Theorem: Filter.map_one
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rw [Filter.map_one', map_one, pure_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type ?u.20040
δ : Type ?u.20043
ε : Type ?u.20046
inst✝² : One α
f : Filter α
s : Set α
inst✝¹ : One β
inst✝ : OneHomClass F α β
φ : F
⊢ map (↑φ) 1 = 1
Theorem: Nat.ArithmeticFunction.IsMultiplicative.map_prod
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: induction' s using Finset.induction_on with a s has ih hs
state_before: R : Type u_2
ι : Type u_1
inst✝ : CommMonoidWithZero R
g : ι → ℕ
f : ArithmeticFunction R
hf : IsMultiplicative f
s : Finset ι
hs : Set.Pairwise (↑s) (coprime on g)
⊢ ↑f (∏ i in s, g i) = ∏ i in s, ↑f (g i)

tactic: rw [coe_insert, Set.pairwise_insert_of_symmetric (coprime.symmetric.comap g)] at hs
state_before: case insert
R : Type u_2
ι : Type u_1
inst✝ : CommMonoidWithZero R
g : ι → ℕ
f : ArithmeticFunction R
hf : IsMultiplicative f
s✝ : Finset ι
hs✝ : Set.Pairwise (↑s✝) (coprime on g)
a : ι
s : Finset ι
has : ¬a ∈ s
ih : Set.Pairwise (↑s) (coprime on g) → ↑f (∏ i in s, g i) = ∏ i in s, ↑f (g i)
hs : Set.Pairwise (↑(insert a s)) (coprime on g)
⊢ ↑f (∏ i in insert a s, g i) = ∏ i in insert a s, ↑f (g i)

tactic: rw [prod_insert has, prod_insert has, hf.map_mul_of_coprime, ih hs.1]
state_before: case insert
R : Type u_2
ι : Type u_1
inst✝ : CommMonoidWithZero R
g : ι → ℕ
f : ArithmeticFunction R
hf : IsMultiplicative f
s✝ : Finset ι
hs✝ : Set.Pairwise (↑s✝) (coprime on g)
a : ι
s : Finset ι
has : ¬a ∈ s
ih : Set.Pairwise (↑s) (coprime on g) → ↑f (∏ i in s, g i) = ∏ i in s, ↑f (g i)
hs : Set.Pairwise (↑s) (coprime on g) ∧ ∀ (b : ι), b ∈ ↑s → a ≠ b → (coprime on g) a b
⊢ ↑f (∏ i in insert a s, g i) = ∏ i in insert a s, ↑f (g i)

tactic: exact Nat.coprime_prod_right fun i hi => hs.2 _ hi (hi.ne_of_not_mem has).symm
state_before: case insert
R : Type u_2
ι : Type u_1
inst✝ : CommMonoidWithZero R
g : ι → ℕ
f : ArithmeticFunction R
hf : IsMultiplicative f
s✝ : Finset ι
hs✝ : Set.Pairwise (↑s✝) (coprime on g)
a : ι
s : Finset ι
has : ¬a ∈ s
ih : Set.Pairwise (↑s) (coprime on g) → ↑f (∏ i in s, g i) = ∏ i in s, ↑f (g i)
hs : Set.Pairwise (↑s) (coprime on g) ∧ ∀ (b : ι), b ∈ ↑s → a ≠ b → (coprime on g) a b
⊢ coprime (g a) (∏ x in s, g x)

tactic: simp [hf]
state_before: case empty
R : Type u_2
ι : Type u_1
inst✝ : CommMonoidWithZero R
g : ι → ℕ
f : ArithmeticFunction R
hf : IsMultiplicative f
s : Finset ι
hs✝ : Set.Pairwise (↑s) (coprime on g)
hs : Set.Pairwise (↑∅) (coprime on g)
⊢ ↑f (∏ i in ∅, g i) = ∏ i in ∅, ↑f (g i)
Theorem: AlgebraicGeometry.StructureSheaf.localization_toBasicOpen
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [toBasicOpen, IsLocalization.Away.lift, RingHom.comp_apply, IsLocalization.lift_eq]
state_before: R : Type u
inst✝ : CommRing R
f g : R
⊢ ↑(RingHom.comp (toBasicOpen R f) (algebraMap R (Localization.Away f))) g = ↑(toOpen R (PrimeSpectrum.basicOpen f)) g
Theorem: Nat.factorization_div
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne d 0 with (rfl | hd)
state_before: d n : ℕ
h : d ∣ n
⊢ factorization (n / d) = factorization n - factorization d

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
d n : ℕ
h : d ∣ n
hd : d ≠ 0
⊢ factorization (n / d) = factorization n - factorization d

tactic: apply add_left_injective d.factorization
state_before: case inr.inr
d n : ℕ
h : d ∣ n
hd : d ≠ 0
hn : n ≠ 0
⊢ factorization (n / d) = factorization n - factorization d

tactic: simp only
state_before: case inr.inr.a
d n : ℕ
h : d ∣ n
hd : d ≠ 0
hn : n ≠ 0
⊢ (fun x => x + factorization d) (factorization (n / d)) =
    (fun x => x + factorization d) (factorization n - factorization d)

tactic: rw [tsub_add_cancel_of_le <| (Nat.factorization_le_iff_dvd hd hn).mpr h, ←
  Nat.factorization_mul (Nat.div_pos (Nat.le_of_dvd hn.bot_lt h) hd.bot_lt).ne' hd,
  Nat.div_mul_cancel h]
state_before: case inr.inr.a
d n : ℕ
h : d ∣ n
hd : d ≠ 0
hn : n ≠ 0
⊢ factorization (n / d) + factorization d = factorization n - factorization d + factorization d

tactic: simp [zero_dvd_iff.mp h]
state_before: case inl
n : ℕ
h : 0 ∣ n
⊢ factorization (n / 0) = factorization n - factorization 0

tactic: simp
state_before: case inr.inl
d : ℕ
hd : d ≠ 0
h : d ∣ 0
⊢ factorization (0 / d) = factorization 0 - factorization d
Theorem: CategoryTheory.MonoidalClosed.pre_map
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

tactic: rw [pre, pre, pre, transferNatTransSelf_comp, (tensoringLeft C).map_comp]
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : MonoidalCategory C
A B X X' Y Y' Z : C
inst✝⁴ : Closed A
inst✝³ : Closed B
A₁ A₂ A₃ : C
inst✝² : Closed A₁
inst✝¹ : Closed A₂
inst✝ : Closed A₃
f : A₁ ⟶ A₂
g : A₂ ⟶ A₃
⊢ pre (f ≫ g) = pre g ≫ pre f
Theorem: CategoryTheory.Limits.Types.Limit.π_mk
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: dsimp [Limit.mk]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x : (j : J) → F.obj j
h : ∀ (j j' : J) (f : j ⟶ j'), F.map f (x j) = x j'
j : J
⊢ limit.π F j (mk F x h) = x j

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x : (j : J) → F.obj j
h : ∀ (j j' : J) (f : j ⟶ j'), F.map f (x j) = x j'
j : J
⊢ limit.π F j
      (↑(limitEquivSections F).symm { val := x, property := (_ : ∀ {j j' : J} (f : j ⟶ j'), F.map f (x j) = x j') }) =
    x j
Theorem: Inducing.isClosedMap
File: Mathlib/Topology/Maps.lean

tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.226053
δ : Type ?u.226056
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : Inducing f
h : IsClosed (range f)
⊢ IsClosedMap f

tactic: rcases hf.isClosed_iff.1 hs with ⟨t, ht, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.226053
δ : Type ?u.226056
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : Inducing f
h : IsClosed (range f)
s : Set α
hs : IsClosed s
⊢ IsClosed (f '' s)

tactic: rw [image_preimage_eq_inter_range]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.226053
δ : Type ?u.226056
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : Inducing f
h : IsClosed (range f)
t : Set β
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (f '' (f ⁻¹' t))

tactic: exact ht.inter h
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.226053
δ : Type ?u.226056
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
hf : Inducing f
h : IsClosed (range f)
t : Set β
ht : IsClosed t
hs : IsClosed (f ⁻¹' t)
⊢ IsClosed (t ∩ range f)
Theorem: ModuleCat.MonoidalCategory.leftUnitor_naturality
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

tactic: apply TensorProduct.ext
state_before: R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
⊢ tensorHom (𝟙 (of R R)) f ≫ (leftUnitor N).hom = (leftUnitor M).hom ≫ f

tactic: apply LinearMap.ext_ring
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
⊢ LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) (tensorHom (𝟙 (of R R)) f ≫ (leftUnitor N).hom) =
    LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) ((leftUnitor M).hom ≫ f)

tactic: apply LinearMap.ext
state_before: case H.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
⊢ ↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) (tensorHom (𝟙 (of R R)) f ≫ (leftUnitor N).hom)) 1 =
    ↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) ((leftUnitor M).hom ≫ f)) 1

tactic: intro x
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
⊢ ∀ (x : ↑M),
    ↑(↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) (tensorHom (𝟙 (of R R)) f ≫ (leftUnitor N).hom)) 1) x =
      ↑(↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) ((leftUnitor M).hom ≫ f)) 1) x

tactic: change ((leftUnitor N).hom) ((tensorHom (𝟙 (of R R)) f) ((1 : R) ⊗ₜ[R] x)) =
  f (((leftUnitor M).hom) (1 ⊗ₜ[R] x))
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
x : ↑M
⊢ ↑(↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) (tensorHom (𝟙 (of R R)) f ≫ (leftUnitor N).hom)) 1) x =
    ↑(↑(LinearMap.compr₂ (TensorProduct.mk R ↑(of R R) ↑M) ((leftUnitor M).hom ≫ f)) 1) x

tactic: erw [TensorProduct.lid_tmul, TensorProduct.lid_tmul]
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
x : ↑M
⊢ ↑(leftUnitor N).hom (↑(tensorHom (𝟙 (of R R)) f) (1 ⊗ₜ[R] x)) = ↑f (↑(leftUnitor M).hom (1 ⊗ₜ[R] x))

tactic: rw [LinearMap.map_smul]
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
x : ↑M
⊢ ↑(𝟙 (of R R)) (1, x).fst • ↑f (1, x).snd = ↑f (1 • x)

tactic: rfl
state_before: case H.h.h
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
f : M ⟶ N
x : ↑M
⊢ ↑(𝟙 (of R R)) (1, x).fst • ↑f (1, x).snd = 1 • ↑f x
Theorem: PGame.zero_le_add_left_neg
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_le_neg_iff, neg_zero]
state_before: x : PGame
⊢ 0 ≤ -x + x

tactic: exact neg_add_le.trans (add_left_neg_le_zero _)
state_before: x : PGame
⊢ -(-x + x) ≤ 0
Theorem: topologicalSpace_eq_iff
File: Mathlib/Topology/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
t t' : TopologicalSpace α
h : ∀ (s : Set α), IsOpen s ↔ IsOpen s
⊢ t = t'

tactic: exact h _
state_before: case a.h.a
α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
t t' : TopologicalSpace α
h : ∀ (s : Set α), IsOpen s ↔ IsOpen s
x✝ : Set α
⊢ IsOpen x✝ ↔ IsOpen x✝
Theorem: CategoryTheory.IsFiltered.span
File: Mathlib/CategoryTheory/Filtered.lean

tactic: simpa only [← Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
i j j' : C
f : i ⟶ j
f' : i ⟶ j'
K : C
G : j ⟶ K
G' : j' ⟶ K
h✝ : True
k : C
e : K ⟶ k
he : (f ≫ G) ≫ e = (f' ≫ G') ≫ e
⊢ f ≫ G ≫ e = f' ≫ G' ≫ e
Theorem: lp.isLUB_norm
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [lp.norm_eq_ciSup]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : { x // x ∈ lp E ⊤ }
⊢ IsLUB (Set.range fun i => ‖↑f i‖) ‖f‖

tactic: exact isLUB_ciSup (lp.memℓp f)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : { x // x ∈ lp E ⊤ }
⊢ IsLUB (Set.range fun i => ‖↑f i‖) (⨆ (i : α), ‖↑f i‖)
Theorem: SimpleGraph.fromEdgeSet_univ
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext (v w)
state_before: ι : Sort ?u.83299
𝕜 : Type ?u.83302
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ fromEdgeSet Set.univ = ⊤

tactic: simp only [fromEdgeSet_adj, Set.mem_univ, true_and_iff, top_adj]
state_before: case Adj.h.h.a
ι : Sort ?u.83299
𝕜 : Type ?u.83302
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ Adj (fromEdgeSet Set.univ) v w ↔ Adj ⊤ v w
Theorem: List.IsRotated.cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: obtain ⟨k, rfl⟩ := h
state_before: α : Type u
l✝ l'✝ l l' : List α
h : l ~r l'
⊢ List.cyclicPermutations l ~r List.cyclicPermutations l'

tactic: exact ⟨k, by simp⟩
state_before: case intro
α : Type u
l✝ l' l : List α
k : ℕ
⊢ List.cyclicPermutations l ~r List.cyclicPermutations (rotate l k)

tactic: simp
state_before: α : Type u
l✝ l' l : List α
k : ℕ
⊢ rotate (List.cyclicPermutations l) k = List.cyclicPermutations (rotate l k)
Theorem: MeasureTheory.Measure.restrict_biUnion_congr
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: haveI := hc.toEncodable
state_before: α : Type u_2
β : Type ?u.316219
γ : Type ?u.316222
δ : Type ?u.316225
ι : Type u_1
R : Type ?u.316231
R' : Type ?u.316234
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : Set ι
t : ι → Set α
hc : Set.Countable s
⊢ restrict μ (⋃ (i : ι) (_ : i ∈ s), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ s), t i) ↔
    ∀ (i : ι), i ∈ s → restrict μ (t i) = restrict ν (t i)

tactic: simp only [biUnion_eq_iUnion, SetCoe.forall', restrict_iUnion_congr]
state_before: α : Type u_2
β : Type ?u.316219
γ : Type ?u.316222
δ : Type ?u.316225
ι : Type u_1
R : Type ?u.316231
R' : Type ?u.316234
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : Set ι
t : ι → Set α
hc : Set.Countable s
this : Encodable ↑s
⊢ restrict μ (⋃ (i : ι) (_ : i ∈ s), t i) = restrict ν (⋃ (i : ι) (_ : i ∈ s), t i) ↔
    ∀ (i : ι), i ∈ s → restrict μ (t i) = restrict ν (t i)
Theorem: IsLocalization.algebraMap_eq_map_map_submonoid
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [← IsScalarTower.algebraMap_apply R S Sₘ, ← IsScalarTower.algebraMap_apply R Rₘ Sₘ]
state_before: R : Type u_3
inst✝¹² : CommRing R
M : Submonoid R
S : Type u_4
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R S
P : Type ?u.3321764
inst✝⁹ : CommRing P
Rₘ : Type u_1
Sₘ : Type u_2
inst✝⁸ : CommRing Rₘ
inst✝⁷ : CommRing Sₘ
inst✝⁶ : Algebra R Rₘ
inst✝⁵ : IsLocalization M Rₘ
inst✝⁴ : Algebra S Sₘ
i : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ
inst✝³ : Algebra Rₘ Sₘ
inst✝² : Algebra R Sₘ
inst✝¹ : IsScalarTower R Rₘ Sₘ
inst✝ : IsScalarTower R S Sₘ
x : R
⊢ ↑(algebraMap Rₘ Sₘ) (↑(algebraMap R Rₘ) x) = ↑(algebraMap S Sₘ) (↑(algebraMap R S) x)
Theorem: Commute.smul_left_iff
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: rw [Commute.symm_iff, Commute.smul_right_iff, Commute.symm_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : Group α
inst✝³ : MulAction α β
inst✝² : Mul β
inst✝¹ : SMulCommClass α β β
inst✝ : IsScalarTower α β β
a b : β
r : α
⊢ Commute (r • a) b ↔ Commute a b
Theorem: Int.neg_sub
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.sub_eq_add_neg, Int.add_comm]
state_before: a b : Int
⊢ -(a - b) = b - a
Theorem: YoungDiagram.row_eq_prod
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: ext ⟨a, b⟩
state_before: μ : YoungDiagram
i : ℕ
⊢ row μ i = {i} ×ˢ Finset.range (rowLen μ i)

tactic: simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_row_iff,
  mem_iff_lt_rowLen, and_comm, and_congr_right_iff]
state_before: case a.mk
μ : YoungDiagram
i a b : ℕ
⊢ (a, b) ∈ row μ i ↔ (a, b) ∈ {i} ×ˢ Finset.range (rowLen μ i)

tactic: rintro rfl
state_before: case a.mk
μ : YoungDiagram
i a b : ℕ
⊢ a = i → (b < rowLen μ a ↔ b < rowLen μ i)

tactic: rfl
state_before: case a.mk
μ : YoungDiagram
a b : ℕ
⊢ b < rowLen μ a ↔ b < rowLen μ a