1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: biInf_le
File: Mathlib/Order/CompleteLattice.lean

tactic: simpa only [iInf_subtype'] using iInf_le (ι := s) (f := f ∘ (↑)) ⟨i, hi⟩
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
inst✝ : CompleteLattice α
f✝ g s✝ t : ι✝ → α
a b : α
ι : Type u_9
s : Set ι
f : ι → α
i : ι
hi : i ∈ s
⊢ ⨅ i ∈ s, f i ≤ f i
state_after: no goals
Theorem: TopologicalSpace.IsSeparable.iUnion
File: Mathlib/Topology/Bases.lean

tactic: choose c hc h'c using hs
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
ι : Sort u_2
inst✝ : Countable ι
s : ι → Set α
hs : ∀ (i : ι), IsSeparable (s i)
⊢ IsSeparable (⋃ i, s i)
state_after: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
ι : Sort u_2
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), (c i).Countable
h'c : ∀ (i : ι), s i ⊆ closure (c i)
⊢ IsSeparable (⋃ i, s i)

tactic: refine ⟨⋃ i, c i, countable_iUnion hc, iUnion_subset_iff.2 fun i => ?_⟩
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
ι : Sort u_2
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), (c i).Countable
h'c : ∀ (i : ι), s i ⊆ closure (c i)
⊢ IsSeparable (⋃ i, s i)
state_after: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
ι : Sort u_2
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), (c i).Countable
h'c : ∀ (i : ι), s i ⊆ closure (c i)
i : ι
⊢ s i ⊆ closure (⋃ i, c i)

tactic: exact (h'c i).trans (closure_mono (subset_iUnion _ i))
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
ι : Sort u_2
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), (c i).Countable
h'c : ∀ (i : ι), s i ⊆ closure (c i)
i : ι
⊢ s i ⊆ closure (⋃ i, c i)
state_after: no goals
Theorem: MeasureTheory.tilted_apply_eq_ofReal_integral'
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: by_cases hf : Integrable (fun x ↦ exp (f x)) μ
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
⊢ (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, rexp (f a) / ∫ (x : α), rexp (f x) ∂μ ∂μ)
state_after: case pos
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, rexp (f a) / ∫ (x : α), rexp (f x) ∂μ ∂μ)

case neg
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, rexp (f a) / ∫ (x : α), rexp (f x) ∂μ ∂μ)

tactic: rw [tilted_apply' _ _ hs, ← ofReal_integral_eq_lintegral_ofReal]
state_before: case pos
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, rexp (f a) / ∫ (x : α), rexp (f x) ∂μ ∂μ)
state_after: case pos.hfi
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ Integrable (fun a => rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) (μ.restrict s)

case pos.f_nn
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ 0 ≤ᶠ[ae (μ.restrict s)] fun a => rexp (f a) / ∫ (x : α), rexp (f x) ∂μ

tactic: exact hf.integrableOn.div_const _
state_before: case pos.hfi
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ Integrable (fun a => rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) (μ.restrict s)
state_after: no goals

tactic: exact ae_of_all _ (fun _ ↦ by positivity)
state_before: case pos.f_nn
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
⊢ 0 ≤ᶠ[ae (μ.restrict s)] fun a => rexp (f a) / ∫ (x : α), rexp (f x) ∂μ
state_after: no goals

tactic: positivity
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : Integrable (fun x => rexp (f x)) μ
x✝ : α
⊢ 0 x✝ ≤ (fun a => rexp (f a) / ∫ (x : α), rexp (f x) ∂μ) x✝
state_after: no goals

tactic: simp only [hf, not_false_eq_true, tilted_of_not_integrable, Measure.coe_zero,
  Pi.zero_apply, integral_undef hf, div_zero, integral_zero, ENNReal.ofReal_zero]
state_before: case neg
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ : α → ℝ
s : Set α
f : α → ℝ
hs : MeasurableSet s
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.tilted f) s = ENNReal.ofReal (∫ (a : α) in s, rexp (f a) / ∫ (x : α), rexp (f x) ∂μ ∂μ)
state_after: no goals
Theorem: Real.eulerMascheroniSeq_zero
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: simp [eulerMascheroniSeq, harmonic_zero]
state_before: ⊢ eulerMascheroniSeq 0 = 0
state_after: no goals
Theorem: Real.map_toNNReal_atTop
File: Mathlib/Topology/Instances/NNReal.lean

tactic: rw [← map_coe_atTop, Function.LeftInverse.filter_map @Real.toNNReal_coe]
state_before: α : Type u_1
⊢ Filter.map Real.toNNReal atTop = atTop
state_after: no goals
Theorem: sup_inf_inf_compl
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← sdiff_eq, sup_inf_sdiff _ _]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ x ⊓ y ⊔ x ⊓ yᶜ = x
state_after: no goals
Theorem: MeasureTheory.Measure.comap_preimage
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comap_apply₀ _ _ hf h (hf' hs).nullMeasurableSet, image_preimage_eq_inter_range]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
s : Set β
hf : Injective f
hf' : Measurable f
h : ∀ (t : Set α), MeasurableSet t → NullMeasurableSet (f '' t) μ
hs : MeasurableSet s
⊢ (comap f μ) (f ⁻¹' s) = μ (s ∩ range f)
state_after: no goals
Theorem: CoxeterSystem.wordProd_singleton
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: simp [wordProd]
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
⊢ cs.wordProd [i] = cs.simple i
state_after: no goals
Theorem: NormedAddGroupHom.coe_inj
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: cases f
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
H : ⇑f = ⇑g
⊢ f = g
state_after: case mk
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
g : NormedAddGroupHom V₁ V₂
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H : ⇑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = ⇑g
⊢ { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = g

tactic: cases g
state_before: case mk
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
g : NormedAddGroupHom V₁ V₂
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H : ⇑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = ⇑g
⊢ { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = g
state_after: case mk.mk
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
toFun✝¹ : V₁ → V₂
map_add'✝¹ : ∀ (v₁ v₂ : V₁), toFun✝¹ (v₁ + v₂) = toFun✝¹ v₁ + toFun✝¹ v₂
bound'✝¹ : ∃ C, ∀ (v : V₁), ‖toFun✝¹ v‖ ≤ C * ‖v‖
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H :
  ⇑{ toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    ⇑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
⊢ { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }

tactic: congr
state_before: case mk.mk
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
toFun✝¹ : V₁ → V₂
map_add'✝¹ : ∀ (v₁ v₂ : V₁), toFun✝¹ (v₁ + v₂) = toFun✝¹ v₁ + toFun✝¹ v₂
bound'✝¹ : ∃ C, ∀ (v : V₁), ‖toFun✝¹ v‖ ≤ C * ‖v‖
toFun✝ : V₁ → V₂
map_add'✝ : ∀ (v₁ v₂ : V₁), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : V₁), ‖toFun✝ v‖ ≤ C * ‖v‖
H :
  ⇑{ toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    ⇑{ toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
⊢ { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
state_after: no goals
Theorem: Nat.div_mul_div_le
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [hb]
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : b = 0
⊢ a / b * (c / d) ≤ a * c / (b * d)
state_after: no goals

tactic: simp [hd]
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : d = 0
⊢ a / b * (c / d) ≤ a * c / (b * d)
state_after: no goals

tactic: have hbd : b * d ≠ 0 := Nat.mul_ne_zero hb hd
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
⊢ a / b * (c / d) ≤ a * c / (b * d)
state_after: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) ≤ a * c / (b * d)

tactic: rw [le_div_iff_mul_le (Nat.pos_of_ne_zero hbd)]
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) ≤ a * c / (b * d)
state_after: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) ≤ a * c

tactic: transitivity ((a / b) * b) * ((c / d) * d)
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) ≤ a * c
state_after: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) ≤ a / b * b * (c / d * d)

a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * b * (c / d * d) ≤ a * c

tactic: apply Nat.le_of_eq
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) ≤ a / b * b * (c / d * d)
state_after: case p
a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) = a / b * b * (c / d * d)

tactic: simp only [Nat.mul_assoc, Nat.mul_left_comm]
state_before: case p
a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * (c / d) * (b * d) = a / b * b * (c / d * d)
state_after: no goals

tactic: apply Nat.mul_le_mul <;> apply div_mul_le_self
state_before: a✝ b✝ c✝ d✝ m n k : ℕ
p q : ℕ → Prop
a b c d : ℕ
hb : ¬b = 0
hd : ¬d = 0
hbd : b * d ≠ 0
⊢ a / b * b * (c / d * d) ≤ a * c
state_after: no goals
Theorem: LipschitzWith.prod_mk_left
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simpa only [max_eq_right zero_le_one] using (LipschitzWith.const a).prod LipschitzWith.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
a : α
⊢ LipschitzWith 1 (Prod.mk a)
state_after: no goals
Theorem: Ideal.mem_toCotangent_ker
File: Mathlib/RingTheory/Ideal/Cotangent.lean

tactic: rw [← I.map_toCotangent_ker]
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ I ^ 2
state_after: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent)

tactic: simp
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent)
state_after: no goals
Theorem: SemidirectProduct.lift_comp_inr
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
⊢ (lift f₁ f₂ h).comp inr = f₂
state_after: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
x✝ : G
⊢ ((lift f₁ f₂ h).comp inr) x✝ = f₂ x✝

tactic: simp
state_before: case h
N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
x✝ : G
⊢ ((lift f₁ f₂ h).comp inr) x✝ = f₂ x✝
state_after: no goals
Theorem: Ideal.span_pair_comm
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: simp only [span_insert, sup_comm]
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
⊢ span {x, y} = span {y, x}
state_after: no goals
Theorem: Polynomial.Chebyshev.U_eq
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: linear_combination (norm := ring_nf) U_add_two R (n - 2)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ U R n = 2 * X * U R (n - 1) - U R (n - 2)
state_after: no goals
Theorem: CategoryTheory.IsPushout.of_is_coproduct
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: dsimp
state_before: case mk.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : BinaryCofan X Y
h : IsColimit c
t : IsInitial Z
⊢ c.ι.app { as := WalkingPair.right } ≫ (Iso.refl c.pt).hom =
    (BinaryCofan.mk (c.ι.1 { as := WalkingPair.left }) (c.ι.1 { as := WalkingPair.right })).ι.app
      { as := WalkingPair.right }
state_after: case mk.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : BinaryCofan X Y
h : IsColimit c
t : IsInitial Z
⊢ c.inr ≫ 𝟙 c.pt = c.inr

tactic: simp
state_before: case mk.right
C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : BinaryCofan X Y
h : IsColimit c
t : IsInitial Z
⊢ c.inr ≫ 𝟙 c.pt = c.inr
state_after: no goals
Theorem: Matrix.single_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: have : ∀ j ≠ i, Pi.single (f := fun _ => α) i x j * v j = 0 := fun j hij => by
  simp [Pi.single_eq_of_ne hij]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i : m
⊢ Pi.single i x ⬝ᵥ v = x * v i
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i : m
this : ∀ (j : m), j ≠ i → Pi.single i x j * v j = 0
⊢ Pi.single i x ⬝ᵥ v = x * v i

tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i : m
this : ∀ (j : m), j ≠ i → Pi.single i x j * v j = 0
⊢ Pi.single i x ⬝ᵥ v = x * v i
state_after: no goals

tactic: simp [Pi.single_eq_of_ne hij]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x : α
i j : m
hij : j ≠ i
⊢ Pi.single i x j * v j = 0
state_after: no goals
Theorem: HasDerivAt.comp_const_add
File: Mathlib/Analysis/Calculus/Deriv/Shift.lean

tactic: simpa [Function.comp_def] using HasDerivAt.scomp (𝕜 := 𝕜) x hh <| hasDerivAt_id' x |>.const_add a
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
a x : 𝕜
𝕜' : Type u_2
inst✝¹ : NormedAddCommGroup 𝕜'
inst✝ : NormedSpace 𝕜 𝕜'
h : 𝕜 → 𝕜'
h' : 𝕜'
hh : HasDerivAt h h' (a + x)
⊢ HasDerivAt (fun x => h (a + x)) h' x
state_after: no goals
Theorem: CategoryTheory.tensorLeftHomEquiv_whiskerRight_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv, leftAdjointMate]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) (f ▷ ᘁY ≫ ε_ (ᘁY) Y) = (ᘁf) ≫ (ρ_ ᘁX).inv
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (α_ (ᘁX) X ᘁY).hom ≫ ᘁX ◁ (f ▷ ᘁY ≫ ε_ (ᘁY) Y) =
    ((λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom) ≫ (ρ_ ᘁX).inv

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (α_ (ᘁX) X ᘁY).hom ≫ ᘁX ◁ (f ▷ ᘁY ≫ ε_ (ᘁY) Y) =
    ((λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom) ≫ (ρ_ ᘁX).inv
state_after: no goals
Theorem: untrop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: rw [iInf,← Set.image_univ,← coe_univ, untrop_sum_eq_sInf_image]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder R
inst✝ : Fintype S
f : S → Tropical (WithTop R)
⊢ untrop (∑ i : S, f i) = ⨅ i, untrop (f i)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder R
inst✝ : Fintype S
f : S → Tropical (WithTop R)
⊢ sInf (untrop ∘ f '' ↑univ) = sInf ((fun i => untrop (f i)) '' ↑univ)

tactic: rfl
state_before: R : Type u_1
S : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder R
inst✝ : Fintype S
f : S → Tropical (WithTop R)
⊢ sInf (untrop ∘ f '' ↑univ) = sInf ((fun i => untrop (f i)) '' ↑univ)
state_after: no goals
Theorem: FreeGroup.Red.Step.lift
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: cases' H with _ _ _ b
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f✝ : α → β
x y : FreeGroup α
f : α → β
H : Step L₁ L₂
⊢ Lift.aux f L₁ = Lift.aux f L₂
state_after: case not
α : Type u
L L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f✝ : α → β
x y : FreeGroup α
f : α → β
L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b : Bool
⊢ Lift.aux f (L₁✝ ++ (x✝, b) :: (x✝, !b) :: L₂✝) = Lift.aux f (L₁✝ ++ L₂✝)

tactic: cases b <;> simp [Lift.aux]
state_before: case not
α : Type u
L L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f✝ : α → β
x y : FreeGroup α
f : α → β
L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b : Bool
⊢ Lift.aux f (L₁✝ ++ (x✝, b) :: (x✝, !b) :: L₂✝) = Lift.aux f (L₁✝ ++ L₂✝)
state_after: no goals
Theorem: Finset.Iic_eq_cons_Iio
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: classical rw [cons_eq_insert, Iio_insert]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderBot α
b : α
⊢ Iic b = cons b (Iio b) ⋯
state_after: no goals

tactic: rw [cons_eq_insert, Iio_insert]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderBot α
b : α
⊢ Iic b = cons b (Iio b) ⋯
state_after: no goals
Theorem: fderiv.comp_deriv_of_eq
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: rw [hy] at hl
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
l : F → E
l' : F →L[𝕜] E
y : F
hl : DifferentiableAt 𝕜 l y
hf : DifferentiableAt 𝕜 f x
hy : y = f x
⊢ deriv (l ∘ f) x = (fderiv 𝕜 l (f x)) (deriv f x)
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
l : F → E
l' : F →L[𝕜] E
y : F
hl : DifferentiableAt 𝕜 l (f x)
hf : DifferentiableAt 𝕜 f x
hy : y = f x
⊢ deriv (l ∘ f) x = (fderiv 𝕜 l (f x)) (deriv f x)

tactic: exact fderiv.comp_deriv x hl hf
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
l : F → E
l' : F →L[𝕜] E
y : F
hl : DifferentiableAt 𝕜 l (f x)
hf : DifferentiableAt 𝕜 f x
hy : y = f x
⊢ deriv (l ∘ f) x = (fderiv 𝕜 l (f x)) (deriv f x)
state_after: no goals
Theorem: Nat.pred_eq_of_eq_succ
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [H]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
H : m = n.succ
⊢ m.pred = n
state_after: no goals
Theorem: Complex.abs_le_abs_re_add_abs_im
File: Mathlib/Data/Complex/Abs.lean

tactic: simpa [re_add_im] using Complex.abs.add_le z.re (z.im * I)
state_before: z : ℂ
⊢ abs z ≤ |z.re| + |z.im|
state_after: no goals