tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.SemiadditiveOfBinaryBiproducts.isUnital_rightAdd
File: Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean

tactic: exact ⟨⟨fun f => by simp [h₂ f, rightAdd, biprod.lift_snd_assoc, Category.id_comp]⟩,
  ⟨fun f => by simp [h₁ f, rightAdd, biprod.lift_fst_assoc, Category.id_comp]⟩⟩
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
h₁ : ∀ (f : X ⟶ Y), biprod.desc f 0 = biprod.fst ≫ f
⊢ EckmannHilton.IsUnital (fun x x_1 => rightAdd X Y x x_1) 0

tactic: intro f
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
⊢ ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f

tactic: ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.desc 0 f = biprod.snd ≫ f

tactic: aesop_cat
state_before: case h₀
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.inl ≫ biprod.desc 0 f = biprod.inl ≫ biprod.snd ≫ f

tactic: simp only [biprod.inr_desc, BinaryBicone.inr_snd_assoc]
state_before: case h₁
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
f : X ⟶ Y
⊢ biprod.inr ≫ biprod.desc 0 f = biprod.inr ≫ biprod.snd ≫ f

tactic: intro f
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
⊢ ∀ (f : X ⟶ Y), biprod.desc f 0 = biprod.fst ≫ f

tactic: ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
f : X ⟶ Y
⊢ biprod.desc f 0 = biprod.fst ≫ f

tactic: aesop_cat
state_before: case h₀
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
f : X ⟶ Y
⊢ biprod.inl ≫ biprod.desc f 0 = biprod.inl ≫ biprod.fst ≫ f

tactic: simp only [biprod.inr_desc, BinaryBicone.inr_fst_assoc, zero_comp]
state_before: case h₁
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
f : X ⟶ Y
⊢ biprod.inr ≫ biprod.desc f 0 = biprod.inr ≫ biprod.fst ≫ f

tactic: simp [h₂ f, rightAdd, biprod.lift_snd_assoc, Category.id_comp]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
h₁ : ∀ (f : X ⟶ Y), biprod.desc f 0 = biprod.fst ≫ f
f : X ⟶ Y
⊢ rightAdd X Y 0 f = f

tactic: simp [h₁ f, rightAdd, biprod.lift_fst_assoc, Category.id_comp]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproducts C
X Y : C
h₂ : ∀ (f : X ⟶ Y), biprod.desc 0 f = biprod.snd ≫ f
h₁ : ∀ (f : X ⟶ Y), biprod.desc f 0 = biprod.fst ≫ f
f : X ⟶ Y
⊢ rightAdd X Y f 0 = f
Theorem: Configuration.ProjectivePlane.two_lt_pointCount
File: Mathlib/Combinatorics/Configuration.lean

tactic: simpa only [pointCount_eq P l, Nat.succ_lt_succ_iff] using one_lt_order P L
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
l : L
⊢ 2 < pointCount P l
Theorem: ContinuousLinearMap.comp_sub
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_6
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_4
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_5
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type ?u.856610
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M →SL[σ₁₂] M₂
⊢ comp g (f₁ - f₂) = comp g f₁ - comp g f₂

tactic: simp
state_before: case h
R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_6
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_4
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_5
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type ?u.856610
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M →SL[σ₁₂] M₂
x✝ : M
⊢ ↑(comp g (f₁ - f₂)) x✝ = ↑(comp g f₁ - comp g f₂) x✝
Theorem: Equiv.Perm.sameCycle_conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [conj_zpow, eq_inv_iff_eq]
state_before: ι : Type ?u.37340
α : Type u_1
β : Type ?u.37346
f g : Perm α
p : α → Prop
x y z : α
i : ℤ
⊢ ↑((g * f * g⁻¹) ^ i) x = y ↔ ↑(f ^ i) (↑g⁻¹ x) = ↑g⁻¹ y
Theorem: toIocMod_eq_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod_sub_eq_sub, zero_add, sub_add_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a b = toIocMod hp 0 (b - a) + a
Theorem: integral_id
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have := @integral_pow a b 1
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, x) = (b ^ 2 - a ^ 2) / 2

tactic: norm_num at this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, x ^ 1) = (b ^ (1 + 1) - a ^ (1 + 1)) / (↑1 + 1)
⊢ (∫ (x : ℝ) in a..b, x) = (b ^ 2 - a ^ 2) / 2

tactic: exact this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, x) = (b ^ 2 - a ^ 2) / 2
⊢ (∫ (x : ℝ) in a..b, x) = (b ^ 2 - a ^ 2) / 2
Theorem: Set.Ico_insert_right
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [insert_eq, union_comm, Ico_union_right h]
state_before: α : Type u_1
β : Type ?u.48083
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ insert b (Ico a b) = Icc a b
Theorem: OpenEmbedding.open_iff_image_open
File: Mathlib/Topology/Maps.lean

tactic: convert ← h.preimage hf.toEmbedding.continuous
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.236323
δ : Type ?u.236326
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : OpenEmbedding f
s : Set α
h : IsOpen (f '' s)
⊢ IsOpen s

tactic: apply preimage_image_eq _ hf.inj
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type ?u.236323
δ : Type ?u.236326
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : OpenEmbedding f
s : Set α
h : IsOpen (f '' s)
⊢ f ⁻¹' (f '' s) = s
Theorem: GaloisConnection.l_iSup
File: Mathlib/Order/GaloisConnection.lean

tactic: rw [range_comp, ← sSup_range]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.18544
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
l : α → β
u : β → α
gc : GaloisConnection l u
f : ι → α
⊢ IsLUB (range (l ∘ f)) (l (iSup f))

tactic: exact gc.isLUB_l_image (isLUB_sSup _)
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.18544
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
l : α → β
u : β → α
gc : GaloisConnection l u
f : ι → α
⊢ IsLUB (l '' range f) (l (sSup (range f)))
Theorem: PiTensorProduct.gradedMonoid_eq_of_reindex_cast
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: subst hi
state_before: R : Type u_4
M : Type u_3
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ιι : Type u_1
ι : ιι → Type u_2
ai : ιι
a : ⨂[R] (x : ι ai), M
bi : ιι
b : ⨂[R] (x : ι bi), M
hi : ai = bi
h : ↑(reindex R M (Equiv.cast (_ : ι { fst := ai, snd := a }.fst = ι { fst := bi, snd := b }.fst))) a = b
⊢ { fst := ai, snd := a } = { fst := bi, snd := b }

tactic: simp_all
state_before: R : Type u_4
M : Type u_3
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ιι : Type u_1
ι : ιι → Type u_2
ai : ιι
a b : ⨂[R] (x : ι ai), M
h : ↑(reindex R M (Equiv.cast (_ : ι { fst := ai, snd := a }.fst = ι { fst := ai, snd := b }.fst))) a = b
⊢ { fst := ai, snd := a } = { fst := ai, snd := b }
Theorem: WType.rightInverse_list
File: Mathlib/Data/W/Constructions.lean

tactic: simp only [toList, rightInverse_list tl]
state_before: γ : Type u
hd : γ
tl : List γ
⊢ toList γ (ofList γ (hd :: tl)) = hd :: tl
Theorem: PadicSeq.norm_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have h1 : ¬(1 : PadicSeq p) ≈ 0 := one_not_equiv_zero _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ norm 1 = 1

tactic: simp [h1, norm, hp.1.one_lt]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
h1 : ¬1 ≈ 0
⊢ norm 1 = 1
Theorem: NNReal.le_inv_iff_mul_le
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← mul_le_mul_left (pos_iff_ne_zero.2 h), mul_inv_cancel h, mul_comm]
state_before: r p : ℝ≥0
h : p ≠ 0
⊢ r ≤ p⁻¹ ↔ r * p ≤ 1
Theorem: Set.unbounded_lt_inter_lt
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Unbounded (fun x x_1 => x < x_1) (s ∩ {b | a < b}) ↔ Unbounded (fun x x_1 => x < x_1) s

tactic: exact bounded_lt_inter_lt a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x < x_1) s
Theorem: algebraMap_isometry
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: refine' Isometry.of_dist_eq fun x y => _
state_before: α : Type ?u.578231
β : Type ?u.578234
γ : Type ?u.578237
ι : Type ?u.578240
𝕜 : Type u_2
𝕜' : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedRing 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormOneClass 𝕜'
⊢ Isometry ↑(algebraMap 𝕜 𝕜')

tactic: rw [dist_eq_norm, dist_eq_norm, ← RingHom.map_sub, norm_algebraMap']
state_before: α : Type ?u.578231
β : Type ?u.578234
γ : Type ?u.578237
ι : Type ?u.578240
𝕜 : Type u_2
𝕜' : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedRing 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormOneClass 𝕜'
x y : 𝕜
⊢ dist (↑(algebraMap 𝕜 𝕜') x) (↑(algebraMap 𝕜 𝕜') y) = dist x y
Theorem: List.reduceOption_concat_of_some
File: Mathlib/Data/List/Basic.lean

tactic: simp only [reduceOption_nil, concat_eq_append, reduceOption_append, reduceOption_cons_of_some]
state_before: ι : Type ?u.369210
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List (Option α)
x : α
⊢ reduceOption (concat l (some x)) = concat (reduceOption l) x
Theorem: tsum_ne_zero_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: rw [Ne.def, tsum_eq_zero_iff hf, not_forall]
state_before: ι : Type u_2
κ : Type ?u.55666
α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f : ι → α
a : α
hf : Summable f
⊢ (∑' (i : ι), f i) ≠ 0 ↔ ∃ x, f x ≠ 0
Theorem: WittVector.mapFun.neg
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.310095
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.310110
β : Type ?u.310113
f : R →+* S
x y : 𝕎 R
⊢ mapFun (↑f) (-x) = -mapFun (↑f) x
Theorem: ZMod.int_cast_comp_cast
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
⊢ Int.cast ∘ cast = cast

tactic: ext
state_before: case succ
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
⊢ Int.cast ∘ cast = cast

tactic: simp [ZMod, ZMod.cast]
state_before: case succ.h
R : Type u_1
inst✝ : Ring R
n✝ : ℕ
x✝ : ZMod (Nat.succ n✝)
⊢ (Int.cast ∘ cast) x✝ = ↑x✝
Theorem: le_iff_exists_mul'
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: simp only [mul_comm _ a, le_iff_exists_mul]
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
⊢ a ≤ b ↔ ∃ c, b = c * a
Theorem: Equiv.Perm.filter_parts_partition_eq_cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [parts_partition, filter_add, Multiset.filter_eq_self.2 fun _ => two_le_of_mem_cycleType,
  Multiset.filter_eq_nil.2 fun a h => ?_, add_zero]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
⊢ filter (fun n => 2 ≤ n) (partition σ).parts = cycleType σ

tactic: rw [Multiset.eq_of_mem_replicate h]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
a : ℕ
h : a ∈ replicate (Fintype.card α - Finset.card (support σ)) 1
⊢ ¬2 ≤ a

tactic: decide
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
a : ℕ
h : a ∈ replicate (Fintype.card α - Finset.card (support σ)) 1
⊢ ¬2 ≤ 1
Theorem: LipschitzWith.completion_extension
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: continuity
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ Continuous fun x => dist (Completion.extension f x.fst) (Completion.extension f x.snd)

tactic: continuity
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ Continuous fun x => ↑K * dist x.fst x.snd

tactic: simpa only [extension_coe h.uniformContinuous, Completion.dist_eq] using h.dist_le_mul
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ ∀ (a b : α), dist (Completion.extension f (↑α a)) (Completion.extension f (↑α b)) ≤ ↑K * dist (↑α a) (↑α b)
Theorem: Multiset.traverse_map
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine' Quotient.inductionOn x _
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
⊢ traverse h (map g x) = traverse (h ∘ g) x

tactic: intro
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
⊢ ∀ (a : List α), traverse h (map g (Quotient.mk (isSetoid α) a)) = traverse (h ∘ g) (Quotient.mk (isSetoid α) a)

tactic: simp only [traverse, quot_mk_to_coe, coe_map, lift_coe, Function.comp_apply]
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ traverse h (map g (Quotient.mk (isSetoid α) a✝)) = traverse (h ∘ g) (Quotient.mk (isSetoid α) a✝)

tactic: rw [← Traversable.traverse_map h g, List.map_eq_map]
state_before: F : Type u → Type u
inst✝³ : Applicative F
inst✝² : CommApplicative F
α' β' : Type u
f : α' → F β'
G : Type u_1 → Type u_1
inst✝¹ : Applicative G
inst✝ : CommApplicative G
α β γ : Type u_1
g : α → β
h : β → G γ
x : Multiset α
a✝ : List α
⊢ Coe.coe <$> Traversable.traverse h (List.map g a✝) = Coe.coe <$> Traversable.traverse (h ∘ g) a✝
Theorem: WithZeroTopology.Iio_mem_nhds
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rcases eq_or_ne γ₁ 0 with (rfl | h₀) <;> simp [*, h.ne', Iio_mem_nhds_zero]
state_before: α : Type ?u.83617
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
h : γ₁ < γ₂
⊢ Iio γ₂ ∈ 𝓝 γ₁
Theorem: Part.some_mul_some
File: Mathlib/Data/Part.lean

tactic: simp [mul_def]
state_before: α : Type u_1
β : Type ?u.57768
γ : Type ?u.57771
inst✝ : Mul α
a b : α
⊢ some a * some b = some (a * b)
Theorem: LinearMap.pi_zero
File: Mathlib/LinearAlgebra/Pi.lean

tactic: ext
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
⊢ (pi fun i => 0) = 0

tactic: rfl
state_before: case h.h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
x✝¹ : M₂
x✝ : ι
⊢ ↑(pi fun i => 0) x✝¹ x✝ = ↑0 x✝¹ x✝
Theorem: div_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type ?u.20357
β : Type ?u.20360
G : Type u_1
inst✝ : DivInvOneMonoid G
a : G
⊢ a / 1 = a
Theorem: Real.sign_mul_pos_of_ne_zero
File: Mathlib/Data/Real/Sign.lean

tactic: refine' lt_of_le_of_ne (sign_mul_nonneg r) fun h => hr _
state_before: r : ℝ
hr : r ≠ 0
⊢ 0 < sign r * r

tactic: have hs0 := (zero_eq_mul.mp h).resolve_right hr
state_before: r : ℝ
hr : r ≠ 0
h : 0 = sign r * r
⊢ r = 0

tactic: exact sign_eq_zero_iff.mp hs0
state_before: r : ℝ
hr : r ≠ 0
h : 0 = sign r * r
hs0 : sign r = 0
⊢ r = 0
Theorem: Polynomial.coeff_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: simp (config := { contextual := true }) [scaleRoots, coeff_monomial]
state_before: A : Type ?u.2391
K : Type ?u.2394
R : Type u_1
S : Type ?u.2400
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
s : R
i : ℕ
⊢ coeff (scaleRoots p s) i = coeff p i * s ^ (natDegree p - i)
Theorem: Real.log_two_gt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: norm_num1
state_before: ⊢ 0.6931471803 < 287209 / 414355 - 1 / 10 ^ 10
Theorem: Real.rpow_neg_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: suffices H : x ^ ((-1 : ℤ) : ℝ) = x⁻¹
state_before: x✝ y z x : ℝ
⊢ x ^ (-1) = x⁻¹

tactic: simp only [rpow_int_cast, zpow_one, zpow_neg]
state_before: case H
x✝ y z x : ℝ
⊢ x ^ ↑(-1) = x⁻¹

tactic: rwa [Int.cast_neg, Int.cast_one] at H
state_before: x✝ y z x : ℝ
H : x ^ ↑(-1) = x⁻¹
⊢ x ^ (-1) = x⁻¹
Theorem: Dfinsupp.sum_sub_index
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: have := (liftAddHom (β := β) fun a => AddMonoidHom.ofMapSub (h a) (h_sub a)).map_sub f g
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → AddGroup (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : AddCommGroup γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_sub : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ - b₂) = h i b₁ - h i b₂
⊢ sum (f - g) h = sum f h - sum g h

tactic: rw [liftAddHom_apply, sumAddHom_apply, sumAddHom_apply, sumAddHom_apply] at this
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → AddGroup (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : AddCommGroup γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_sub : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ - b₂) = h i b₁ - h i b₂
this :
  ↑(↑liftAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) (f - g) =
    ↑(↑liftAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) f -
      ↑(↑liftAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) g
⊢ sum (f - g) h = sum f h - sum g h

tactic: exact this
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → AddGroup (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝ : AddCommGroup γ
f g : Π₀ (i : ι), β i
h : (i : ι) → β i → γ
h_sub : ∀ (i : ι) (b₁ b₂ : β i), h i (b₁ - b₂) = h i b₁ - h i b₂
this✝² :
  ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) (f - g) =
    ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) f -
      ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) g
this✝¹ :
  (sum (f - g) fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))) =
    ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) f -
      ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) g
this✝ :
  (sum (f - g) fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))) =
    (sum f fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))) -
      ↑(sumAddHom fun a => AddMonoidHom.ofMapSub (h a) (_ : ∀ (b₁ b₂ : β a), h a (b₁ - b₂) = h a b₁ - h a b₂)) g
this :
  (sum (f - g) fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))) =
    (sum f fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))) -
      sum g fun x => ↑(AddMonoidHom.ofMapSub (h x) (_ : ∀ (b₁ b₂ : β x), h x (b₁ - b₂) = h x b₁ - h x b₂))
⊢ sum (f - g) h = sum f h - sum g h
Theorem: CategoryTheory.Limits.Cofork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← t.app_zero_eq_comp_π_left, ← t.app_zero_eq_comp_π_right]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
t : Cofork f g
⊢ f ≫ π t = g ≫ π t
Theorem: Wbtw.trans_right_ne
File: Mathlib/Analysis/Convex/Between.lean

tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.323287
P : Type u_3
P' : Type ?u.323293
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w x z
h₂ : Wbtw R x y z
h : w ≠ x
⊢ w ≠ y

tactic: exact h (h₁.swap_left_iff.1 h₂)
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.323287
P : Type u_3
P' : Type ?u.323293
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x z : P
h₁ : Wbtw R w x z
h : w ≠ x
h₂ : Wbtw R x w z
⊢ False
Theorem: ConvexOn.smul
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_comm c, smul_comm c]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.724295
α : Type ?u.724298
β : Type u_3
ι : Type ?u.724304
inst✝⁵ : OrderedCommSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
c : 𝕜
hc : 0 ≤ c
hf : ConvexOn 𝕜 s f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ c • (a • f x + b • f y) = a • c • f x + b • c • f y