1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.pair_lt_pair_left
File: Mathlib/Data/Nat/Pairing.lean

tactic: by_cases h₁ : a₁ < b <;> simp [pair, h₁, Nat.add_assoc]
state_before: a₁ a₂ b : ℕ
h : a₁ < a₂
⊢ pair a₁ b < pair a₂ b
state_after: case pos
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
⊢ b * b + a₁ < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)

case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : ¬a₁ < b
⊢ a₁ * a₁ + (a₁ + b) < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)

tactic: by_cases h₂ : a₂ < b <;> simp [pair, h₂, h]
state_before: case pos
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
⊢ b * b + a₁ < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)
state_after: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : ¬a₂ < b
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)

tactic: simp? at h₂ says simp only [not_lt] at h₂
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : ¬a₂ < b
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)
state_after: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)

tactic: apply Nat.add_lt_add_of_le_of_lt
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)
state_after: case neg.hle
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ b * b ≤ a₂ * a₂

case neg.hlt
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ a₁ < a₂ + b

tactic: simp only [not_lt] at h₂
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : ¬a₂ < b
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)
state_after: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ b * b + a₁ < a₂ * a₂ + (a₂ + b)

tactic: exact Nat.mul_self_le_mul_self h₂
state_before: case neg.hle
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ b * b ≤ a₂ * a₂
state_after: no goals

tactic: exact Nat.lt_add_right _ h
state_before: case neg.hlt
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : a₁ < b
h₂ : b ≤ a₂
⊢ a₁ < a₂ + b
state_after: no goals

tactic: simp at h₁
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : ¬a₁ < b
⊢ a₁ * a₁ + (a₁ + b) < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)
state_after: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ + (a₁ + b) < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)

tactic: simp only [not_lt_of_gt (lt_of_le_of_lt h₁ h), ite_false]
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ + (a₁ + b) < if a₂ < b then b * b + a₂ else a₂ * a₂ + (a₂ + b)
state_after: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ + (a₁ + b) < a₂ * a₂ + (a₂ + b)

tactic: apply add_lt_add
state_before: case neg
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ + (a₁ + b) < a₂ * a₂ + (a₂ + b)
state_after: case neg.h₁
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ < a₂ * a₂

case neg.h₂
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ + b < a₂ + b

tactic: exact Nat.mul_self_lt_mul_self h
state_before: case neg.h₁
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ * a₁ < a₂ * a₂
state_after: no goals

tactic: apply Nat.add_lt_add_right
state_before: case neg.h₂
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ + b < a₂ + b
state_after: case neg.h₂.h
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ < a₂

tactic: assumption
state_before: case neg.h₂.h
a₁ a₂ b : ℕ
h : a₁ < a₂
h₁ : b ≤ a₁
⊢ a₁ < a₂
state_after: no goals
Theorem: Vector.get_append_cons_zero
File: Mathlib/Data/Vector/Basic.lean

tactic: omega
state_before: α : Type ?u.53931
m n : ℕ
xs : Vector α n
ys : Vector α m
x : α
⊢ 0 < n.succ + m
state_after: no goals
Theorem: LieModule.iSup_weightSpaceOf_eq_top
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.iSup_coe_toSubmodule,
  LieSubmodule.top_coeSubmodule]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsTriangularizable R L M
x : L
⊢ ⨆ φ, weightSpaceOf M φ x = ⊤
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsTriangularizable R L M
x : L
⊢ ⨆ i, ↑(weightSpaceOf M i x) = ⊤

tactic: exact IsTriangularizable.iSup_eq_top x
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsTriangularizable R L M
x : L
⊢ ⨆ i, ↑(weightSpaceOf M i x) = ⊤
state_after: no goals
Theorem: Real.tendsto_pow_log_div_mul_add_atTop
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: filter_upwards [eventually_gt_atTop (0 : ℝ)] with x hx using by simp [exp_log hx]
state_before: x y a b : ℝ
n : ℕ
ha : a ≠ 0
⊢ (fun x => x ^ n / (a * rexp x + b)) ∘ log =ᶠ[atTop] fun x => log x ^ n / (a * x + b)
state_after: no goals

tactic: simp [exp_log hx]
state_before: x✝ y a b : ℝ
n : ℕ
ha : a ≠ 0
x : ℝ
hx : 0 < x
⊢ ((fun x => x ^ n / (a * rexp x + b)) ∘ log) x = log x ^ n / (a * x + b)
state_after: no goals
Theorem: ContinuousLinearMap.hasFPowerSeriesOnBall
File: Mathlib/Analysis/Analytic/Linear.lean

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F
x : E
⊢ ⊤ ≤ (f.fpowerSeries x).radius
state_after: no goals

tactic: simp [Finset.sum_range_succ, ← sub_sub, hasSum_zero, fpowerSeries]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E →L[𝕜] F
x y✝ : E
x✝ : y✝ ∈ EMetric.ball 0 ⊤
⊢ HasSum (fun n => (f.fpowerSeries x (n + 2)) fun x => y✝)
    (f (x + y✝) - ∑ i ∈ Finset.range 2, (f.fpowerSeries x i) fun x => y✝)
state_after: no goals
Theorem: cpow_eq_nhds'
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: suffices ∀ᶠ x : ℂ × ℂ in 𝓝 p, x.1 ≠ 0 from
  this.mono fun x hx ↦ by
    dsimp only
    rw [cpow_def_of_ne_zero hx]
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => cexp (Complex.log x.1 * x.2)
state_after: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.1 ≠ 0

tactic: refine IsOpen.eventually_mem ?_ hp_fst
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.1 ≠ 0
state_after: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsOpen fun x => x.1 = 0 → False

tactic: change IsOpen { x : ℂ × ℂ | x.1 = 0 }ᶜ
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsOpen fun x => x.1 = 0 → False
state_after: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsOpen {x | x.1 = 0}ᶜ

tactic: rw [isOpen_compl_iff]
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsOpen {x | x.1 = 0}ᶜ
state_after: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsClosed {x | x.1 = 0}

tactic: exact isClosed_eq continuous_fst continuous_const
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
⊢ IsClosed {x | x.1 = 0}
state_after: no goals

tactic: dsimp only
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.1 ≠ 0
x : ℂ × ℂ
hx : x.1 ≠ 0
⊢ (fun x => x.1 ^ x.2) x = (fun x => cexp (Complex.log x.1 * x.2)) x
state_after: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.1 ≠ 0
x : ℂ × ℂ
hx : x.1 ≠ 0
⊢ x.1 ^ x.2 = cexp (Complex.log x.1 * x.2)

tactic: rw [cpow_def_of_ne_zero hx]
state_before: α : Type u_1
p : ℂ × ℂ
hp_fst : p.1 ≠ 0
this : ∀ᶠ (x : ℂ × ℂ) in 𝓝 p, x.1 ≠ 0
x : ℂ × ℂ
hx : x.1 ≠ 0
⊢ x.1 ^ x.2 = cexp (Complex.log x.1 * x.2)
state_after: no goals
Theorem: isCyclic_iff_exists_ofOrder_eq_natCard
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: refine ⟨fun h ↦ h.exists_ofOrder_eq_natCard, fun h ↦ ?_⟩
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
⊢ IsCyclic α ↔ ∃ g, orderOf g = Nat.card α
state_after: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
h : ∃ g, orderOf g = Nat.card α
⊢ IsCyclic α

tactic: obtain ⟨g, hg⟩ := h
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
h : ∃ g, orderOf g = Nat.card α
⊢ IsCyclic α
state_after: case intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
⊢ IsCyclic α

tactic: cases nonempty_fintype α
state_before: case intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
⊢ IsCyclic α
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ IsCyclic α

tactic: refine isCyclic_of_orderOf_eq_card g ?_
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ IsCyclic α
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ orderOf g = Fintype.card α

tactic: simp [hg]
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ orderOf g = Fintype.card α
state_after: no goals
Theorem: MeasureTheory.Measure.toSignedMeasure_eq_toSignedMeasure_iff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: refine ⟨fun h => ?_, fun h => ?_⟩
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ μ.toSignedMeasure = ν.toSignedMeasure ↔ μ = ν
state_after: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
⊢ μ = ν

case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ = ν
⊢ μ.toSignedMeasure = ν.toSignedMeasure

tactic: ext1 i hi
state_before: case refine_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
⊢ μ = ν
state_after: case refine_1.h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
i : Set α
hi : MeasurableSet i
⊢ μ i = ν i

tactic: have : μ.toSignedMeasure i = ν.toSignedMeasure i := by rw [h]
state_before: case refine_1.h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
i : Set α
hi : MeasurableSet i
⊢ μ i = ν i
state_after: case refine_1.h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
i : Set α
hi : MeasurableSet i
this : ↑μ.toSignedMeasure i = ↑ν.toSignedMeasure i
⊢ μ i = ν i

tactic: rwa [toSignedMeasure_apply_measurable hi, toSignedMeasure_apply_measurable hi,
    ENNReal.toReal_eq_toReal] at this
  <;> exact measure_ne_top _ _
state_before: case refine_1.h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
i : Set α
hi : MeasurableSet i
this : ↑μ.toSignedMeasure i = ↑ν.toSignedMeasure i
⊢ μ i = ν i
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ.toSignedMeasure = ν.toSignedMeasure
i : Set α
hi : MeasurableSet i
⊢ ↑μ.toSignedMeasure i = ↑ν.toSignedMeasure i
state_after: no goals

tactic: congr
state_before: case refine_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ = ν
⊢ μ.toSignedMeasure = ν.toSignedMeasure
state_after: no goals
Theorem: AlgEquiv.isSeparable
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [← minpoly.algEquiv_eq e.symm]
state_before: F : Type u_1
K : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring K
inst✝³ : Algebra F K
E : Type u_3
inst✝² : Ring E
inst✝¹ : Algebra F E
e : K ≃ₐ[F] E
inst✝ : IsSeparable F K
x✝ : E
⊢ (minpoly F x✝).Separable
state_after: F : Type u_1
K : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring K
inst✝³ : Algebra F K
E : Type u_3
inst✝² : Ring E
inst✝¹ : Algebra F E
e : K ≃ₐ[F] E
inst✝ : IsSeparable F K
x✝ : E
⊢ (minpoly F (e.symm x✝)).Separable

tactic: exact IsSeparable.separable F _
state_before: F : Type u_1
K : Type u_2
inst✝⁵ : CommRing F
inst✝⁴ : Ring K
inst✝³ : Algebra F K
E : Type u_3
inst✝² : Ring E
inst✝¹ : Algebra F E
e : K ≃ₐ[F] E
inst✝ : IsSeparable F K
x✝ : E
⊢ (minpoly F (e.symm x✝)).Separable
state_after: no goals
Theorem: List.chain_iff_forall₂
File: Mathlib/Data/List/Chain.lean

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a✝ b a : α
⊢ Chain R a [] ↔ [] = [] ∨ Forall₂ R (a :: [].dropLast) []
state_after: no goals

tactic: by_cases h : l = [] <;>
simp [@chain_iff_forall₂ b l, dropLast, *]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ a b : α
l : List α
⊢ Chain R a (b :: l) ↔ b :: l = [] ∨ Forall₂ R (a :: (b :: l).dropLast) (b :: l)
state_after: no goals
Theorem: LinearMap.exists_map_addHaar_eq_smul_addHaar
File: Mathlib/MeasureTheory/Measure/Haar/Disintegration.lean

tactic: rcases L.exists_map_addHaar_eq_smul_addHaar' μ ν h with ⟨c, c_pos, -, hc⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : CompleteSpace 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : MeasurableSpace E
inst✝⁸ : BorelSpace E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : MeasurableSpace F
inst✝⁴ : BorelSpace F
inst✝³ : NormedSpace 𝕜 F
L : E →ₗ[𝕜] F
μ : Measure E
ν : Measure F
inst✝² : μ.IsAddHaarMeasure
inst✝¹ : ν.IsAddHaarMeasure
inst✝ : LocallyCompactSpace E
h : Function.Surjective ⇑L
⊢ ∃ c, 0 < c ∧ map (⇑L) μ = c • ν
state_after: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : CompleteSpace 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : MeasurableSpace E
inst✝⁸ : BorelSpace E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : MeasurableSpace F
inst✝⁴ : BorelSpace F
inst✝³ : NormedSpace 𝕜 F
L : E →ₗ[𝕜] F
μ : Measure E
ν : Measure F
inst✝² : μ.IsAddHaarMeasure
inst✝¹ : ν.IsAddHaarMeasure
inst✝ : LocallyCompactSpace E
h : Function.Surjective ⇑L
c : ℝ≥0∞
c_pos : 0 < c
hc : map (⇑L) μ = (c * addHaar univ) • ν
⊢ ∃ c, 0 < c ∧ map (⇑L) μ = c • ν

tactic: exact ⟨_, by simp [c_pos, NeZero.ne addHaar], hc⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : CompleteSpace 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : MeasurableSpace E
inst✝⁸ : BorelSpace E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : MeasurableSpace F
inst✝⁴ : BorelSpace F
inst✝³ : NormedSpace 𝕜 F
L : E →ₗ[𝕜] F
μ : Measure E
ν : Measure F
inst✝² : μ.IsAddHaarMeasure
inst✝¹ : ν.IsAddHaarMeasure
inst✝ : LocallyCompactSpace E
h : Function.Surjective ⇑L
c : ℝ≥0∞
c_pos : 0 < c
hc : map (⇑L) μ = (c * addHaar univ) • ν
⊢ ∃ c, 0 < c ∧ map (⇑L) μ = c • ν
state_after: no goals

tactic: simp [c_pos, NeZero.ne addHaar]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : CompleteSpace 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : MeasurableSpace E
inst✝⁸ : BorelSpace E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : MeasurableSpace F
inst✝⁴ : BorelSpace F
inst✝³ : NormedSpace 𝕜 F
L : E →ₗ[𝕜] F
μ : Measure E
ν : Measure F
inst✝² : μ.IsAddHaarMeasure
inst✝¹ : ν.IsAddHaarMeasure
inst✝ : LocallyCompactSpace E
h : Function.Surjective ⇑L
c : ℝ≥0∞
c_pos : 0 < c
hc : map (⇑L) μ = (c * addHaar univ) • ν
⊢ 0 < c * addHaar univ
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_compl
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

tactic: simp [IsCaratheodory, diff_eq, add_comm]
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
⊢ m.IsCaratheodory s₁ → m.IsCaratheodory s₁ᶜ
state_after: no goals
Theorem: CategoryTheory.Limits.ImageMap.map_uniq_aux
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: have : map ≫ image.ι g.hom = map' ≫ image.ι g.hom := by rw [map_ι,map_ι']
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
this : map ≫ image.ι g.hom = map' ≫ image.ι g.hom
⊢ map = map'

tactic: apply (cancel_mono (image.ι g.hom)).1 this
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
this : map ≫ image.ι g.hom = map' ≫ image.ι g.hom
⊢ map = map'
state_after: no goals

tactic: rw [map_ι,map_ι']
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map ≫ image.ι g.hom = map' ≫ image.ι g.hom
state_after: no goals
Theorem: Matrix.mul_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
⊢ M * -N = -(M * N)
state_after: case a
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
i✝ : m
j✝ : o
⊢ (M * -N) i✝ j✝ = (-(M * N)) i✝ j✝

tactic: apply dotProduct_neg
state_before: case a
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
i✝ : m
j✝ : o
⊢ (M * -N) i✝ j✝ = (-(M * N)) i✝ j✝
state_after: no goals
Theorem: posMulMono_iff_covariant_pos
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

tactic: obtain ha | ha := a.prop.eq_or_lt
state_before: α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
⊢ ↑a * b ≤ ↑a * c
state_after: case inl
α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
ha : 0 = ↑a
⊢ ↑a * b ≤ ↑a * c

case inr
α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
ha : 0 < ↑a
⊢ ↑a * b ≤ ↑a * c

tactic: simp [← ha]
state_before: case inl
α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
ha : 0 = ↑a
⊢ ↑a * b ≤ ↑a * c
state_after: no goals
Theorem: Nat.card_le_card_of_surjective
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: have : lift.{u} #β ≤ lift.{v} #α := mk_le_of_surjective (ULift.map_surjective.2 hf)
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u
β : Type v
inst✝ : Finite α
f : α → β
hf : Surjective f
⊢ Nat.card β ≤ Nat.card α
state_after: α✝ : Type u_1
β✝ : Type u_2
α : Type u
β : Type v
inst✝ : Finite α
f : α → β
hf : Surjective f
this : lift.{u, v} #β ≤ lift.{v, u} #α
⊢ Nat.card β ≤ Nat.card α

tactic: simpa using toNat_le_toNat this (by simp [lt_aleph0_of_finite])
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u
β : Type v
inst✝ : Finite α
f : α → β
hf : Surjective f
this : lift.{u, v} #β ≤ lift.{v, u} #α
⊢ Nat.card β ≤ Nat.card α
state_after: no goals

tactic: simp [lt_aleph0_of_finite]
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u
β : Type v
inst✝ : Finite α
f : α → β
hf : Surjective f
this : lift.{u, v} #β ≤ lift.{v, u} #α
⊢ lift.{v, u} #α < ℵ₀
state_after: no goals