tasksource/leandojo huggingface dataset:
Theorem: Equiv.apply_swap_eq_self
File: Mathlib/Logic/Equiv/Basic.lean

tactic: by_cases hi : k = i
state_before: α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
v : α → β
i j : α
hv : v i = v j
k : α
⊢ v (↑(swap i j) k) = v k

tactic: by_cases hj : k = j
state_before: case neg
α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
v : α → β
i j : α
hv : v i = v j
k : α
hi : ¬k = i
⊢ v (↑(swap i j) k) = v k

tactic: rw [swap_apply_of_ne_of_ne hi hj]
state_before: case neg
α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
v : α → β
i j : α
hv : v i = v j
k : α
hi : ¬k = i
hj : ¬k = j
⊢ v (↑(swap i j) k) = v k

tactic: rw [hi, swap_apply_left, hv]
state_before: case pos
α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
v : α → β
i j : α
hv : v i = v j
k : α
hi : k = i
⊢ v (↑(swap i j) k) = v k

tactic: rw [hj, swap_apply_right, hv]
state_before: case pos
α : Sort u_2
inst✝ : DecidableEq α
β : Sort u_1
v : α → β
i j : α
hv : v i = v j
k : α
hi : ¬k = i
hj : k = j
⊢ v (↑(swap i j) k) = v k
Theorem: Polynomial.natDegree_int_cast
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← C_eq_int_cast, natDegree_C]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Ring R
n : ℤ
⊢ natDegree ↑n = 0
Theorem: MonotoneOn.Iic_union_Ici
File: Mathlib/Order/Monotone/Union.lean

tactic: rw [← monotoneOn_univ, ← @Iic_union_Ici _ _ a]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : MonotoneOn f (Iic a)
h₂ : MonotoneOn f (Ici a)
⊢ Monotone f

tactic: exact MonotoneOn.union_right h₁ h₂ isGreatest_Iic isLeast_Ici
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : MonotoneOn f (Iic a)
h₂ : MonotoneOn f (Ici a)
⊢ MonotoneOn f (Iic a ∪ Ici a)
Theorem: UInt8.sizeOf
File: src/lean/Init/SizeOfLemmas.lean

tactic: cases a
state_before: a : UInt8
⊢ SizeOf.sizeOf a = toNat a + 2

tactic: simp_arith [UInt8.toNat]
state_before: case mk
val✝ : Fin size
⊢ SizeOf.sizeOf { val := val✝ } = toNat { val := val✝ } + 2
Theorem: Polynomial.coeff_divX
File: Mathlib/Data/Polynomial/Inductions.lean

tactic: rw [add_comm]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ coeff (divX p) n = coeff p (n + 1)

tactic: cases p
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ coeff (divX p) n = coeff p (1 + n)

tactic: rfl
state_before: case ofFinsupp
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff (divX { toFinsupp := toFinsupp✝ }) n = coeff { toFinsupp := toFinsupp✝ } (1 + n)
Theorem: Polynomial.coeff_opRingEquiv
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: induction' p using MulOpposite.rec' with p
state_before: R : Type u_1
inst✝ : Semiring R
p : R[X]ᵐᵒᵖ
n : ℕ
⊢ coeff (↑(opRingEquiv R) p) n = op (coeff (unop p) n)

tactic: cases p
state_before: case h
R : Type u_1
inst✝ : Semiring R
n : ℕ
p : R[X]
⊢ coeff (↑(opRingEquiv R) (op p)) n = op (coeff (unop (op p)) n)

tactic: rfl
state_before: case h.ofFinsupp
R : Type u_1
inst✝ : Semiring R
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff (↑(opRingEquiv R) (op { toFinsupp := toFinsupp✝ })) n = op (coeff (unop (op { toFinsupp := toFinsupp✝ })) n)
Theorem: Unitization.inl_mul
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: simp only [smul_zero, add_zero, MulZeroClass.mul_zero]
state_before: R : Type u_1
A : Type u_2
inst✝² : Monoid R
inst✝¹ : NonUnitalNonAssocSemiring A
inst✝ : DistribMulAction R A
r₁ r₂ : R
⊢ 0 = r₁ • 0 + r₂ • 0 + 0 * 0
Theorem: Nat.leRecOn_trans
File: Mathlib/Data/Nat/Basic.lean

tactic: induction' hmk with k hmk ih
state_before: m✝ n✝ k✝ : ℕ
C : ℕ → Sort u
n m k : ℕ
hnm : n ≤ m
hmk : m ≤ k
next : {k : ℕ} → C k → C (k + 1)
x : C n
⊢ leRecOn (_ : n ≤ k) next x = leRecOn hmk next (leRecOn hnm next x)

tactic: rw [leRecOn_succ (le_trans hnm hmk), ih, leRecOn_succ]
state_before: case step
m✝ n✝ k✝¹ : ℕ
C : ℕ → Sort u
n m k✝ : ℕ
hnm : n ≤ m
next : {k : ℕ} → C k → C (k + 1)
x : C n
k : ℕ
hmk : Nat.le m k
ih : leRecOn (_ : n ≤ k) next x = leRecOn hmk next (leRecOn hnm next x)
⊢ leRecOn (_ : n ≤ succ k) next x = leRecOn (_ : Nat.le m (succ k)) next (leRecOn hnm next x)

tactic: rw [leRecOn_self]
state_before: case refl
m✝ n✝ k✝ : ℕ
C : ℕ → Sort u
n m k : ℕ
hnm : n ≤ m
next : {k : ℕ} → C k → C (k + 1)
x : C n
⊢ leRecOn (_ : n ≤ m) next x = leRecOn (_ : Nat.le m m) next (leRecOn hnm next x)
Theorem: Int.nonneg_of_normalize_eq_self
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [abs_eq_normalize, hz]
state_before: z : ℤ
hz : ↑normalize z = z
⊢ abs z = z
Theorem: tsum_mul_tsum_eq_tsum_sum_range
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simp_rw [← Nat.sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
state_before: ι : Type ?u.34737
κ : Type ?u.34740
R : Type ?u.34743
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.fst * g x.snd
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (n : ℕ), ∑ k in range (n + 1), f k * g (n - k)

tactic: exact tsum_mul_tsum_eq_tsum_sum_antidiagonal hf hg hfg
state_before: ι : Type ?u.34737
κ : Type ?u.34740
R : Type ?u.34743
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
hf : Summable f
hg : Summable g
hfg : Summable fun x => f x.fst * g x.snd
⊢ ((∑' (n : ℕ), f n) * ∑' (n : ℕ), g n) = ∑' (n : ℕ), ∑ ij in Nat.antidiagonal n, f ij.fst * g ij.snd
Theorem: FractionRing.mk_eq_div
File: Mathlib/RingTheory/Localization/FractionRing.lean

tactic: rw [Localization.mk_eq_mk', IsFractionRing.mk'_eq_div]
state_before: R : Type ?u.450373
inst✝⁵ : CommRing R
M : Submonoid R
S : Type ?u.450565
inst✝⁴ : CommRing S
inst✝³ : Algebra R S
P : Type ?u.450802
inst✝² : CommRing P
A : Type u_1
inst✝¹ : CommRing A
inst✝ : IsDomain A
K : Type ?u.450982
r : A
s : { x // x ∈ nonZeroDivisors A }
⊢ Localization.mk r s = ↑(algebraMap A (FractionRing A)) r / ↑(algebraMap A (FractionRing A)) ↑s
Theorem: intervalIntegral.intervalIntegrable_deriv_of_nonneg
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: cases' le_total a b with hab hab
state_before: ι : Type ?u.1879888
𝕜 : Type ?u.1879891
E : Type ?u.1879894
F : Type ?u.1879897
A : Type ?u.1879900
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn g [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivAt g (g' x) x
hpos : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → 0 ≤ g' x
⊢ IntervalIntegrable g' volume a b

tactic: simp only [uIcc_of_le, min_eq_left, max_eq_right, hab, IntervalIntegrable, hab,
  Ioc_eq_empty_of_le, integrableOn_empty, and_true_iff] at hcont hderiv hpos ⊢
state_before: case inl
ι : Type ?u.1879888
𝕜 : Type ?u.1879891
E : Type ?u.1879894
F : Type ?u.1879897
A : Type ?u.1879900
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn g [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivAt g (g' x) x
hpos : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → 0 ≤ g' x
hab : a ≤ b
⊢ IntervalIntegrable g' volume a b

tactic: exact integrableOn_deriv_of_nonneg hcont hderiv hpos
state_before: case inl
ι : Type ?u.1879888
𝕜 : Type ?u.1879891
E : Type ?u.1879894
F : Type ?u.1879897
A : Type ?u.1879900
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hab : a ≤ b
hcont : ContinuousOn g (Icc a b)
hderiv : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hpos : ∀ (x : ℝ), x ∈ Ioo a b → 0 ≤ g' x
⊢ IntegrableOn g' (Ioc a b)

tactic: simp only [uIcc_of_ge, min_eq_right, max_eq_left, hab, IntervalIntegrable, Ioc_eq_empty_of_le,
  integrableOn_empty, true_and_iff] at hcont hderiv hpos ⊢
state_before: case inr
ι : Type ?u.1879888
𝕜 : Type ?u.1879891
E : Type ?u.1879894
F : Type ?u.1879897
A : Type ?u.1879900
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn g [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivAt g (g' x) x
hpos : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → 0 ≤ g' x
hab : b ≤ a
⊢ IntervalIntegrable g' volume a b

tactic: exact integrableOn_deriv_of_nonneg hcont hderiv hpos
state_before: case inr
ι : Type ?u.1879888
𝕜 : Type ?u.1879891
E : Type ?u.1879894
F : Type ?u.1879897
A : Type ?u.1879900
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hab : b ≤ a
hcont : ContinuousOn g (Icc b a)
hderiv : ∀ (x : ℝ), x ∈ Ioo b a → HasDerivAt g (g' x) x
hpos : ∀ (x : ℝ), x ∈ Ioo b a → 0 ≤ g' x
⊢ IntegrableOn g' (Ioc b a)
Theorem: Filter.map_prod_eq_map₂
File: Mathlib/Order/Filter/NAry.lean

tactic: ext s
state_before: α : Type u_1
α' : Type ?u.3075
β : Type u_2
β' : Type ?u.3081
γ : Type u_3
γ' : Type ?u.3087
δ : Type ?u.3090
δ' : Type ?u.3093
ε : Type ?u.3096
ε' : Type ?u.3099
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
⊢ map (fun p => m p.fst p.snd) (f ×ˢ g) = map₂ m f g

tactic: simp [mem_prod_iff, prod_subset_iff]
state_before: case a
α : Type u_1
α' : Type ?u.3075
β : Type u_2
β' : Type ?u.3081
γ : Type u_3
γ' : Type ?u.3087
δ : Type ?u.3090
δ' : Type ?u.3093
ε : Type ?u.3096
ε' : Type ?u.3099
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
s : Set γ
⊢ s ∈ map (fun p => m p.fst p.snd) (f ×ˢ g) ↔ s ∈ map₂ m f g
Theorem: LinearIsometry.toAffineIsometry_linearIsometry
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: ext
state_before: 𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.35987
V₂ : Type u_2
V₃ : Type ?u.35993
V₄ : Type ?u.35996
P₁ : Type ?u.35999
P : Type ?u.36002
P₂ : Type ?u.36005
P₃ : Type ?u.36008
P₄ : Type ?u.36011
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : V →ₗᵢ[𝕜] V₂
⊢ AffineIsometry.linearIsometry (toAffineIsometry f) = f

tactic: rfl
state_before: case h
𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.35987
V₂ : Type u_2
V₃ : Type ?u.35993
V₄ : Type ?u.35996
P₁ : Type ?u.35999
P : Type ?u.36002
P₂ : Type ?u.36005
P₃ : Type ?u.36008
P₄ : Type ?u.36011
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : V →ₗᵢ[𝕜] V₂
x✝ : V
⊢ ↑(AffineIsometry.linearIsometry (toAffineIsometry f)) x✝ = ↑f x✝
Theorem: CategoryTheory.Injective.injective_iff_preservesEpimorphisms_preadditive_yoneda_obj'
File: Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean

tactic: rw [injective_iff_preservesEpimorphisms_yoneda_obj]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Injective J ↔ Functor.PreservesEpimorphisms (preadditiveYonedaObj J)

tactic: refine'
  ⟨fun h : (preadditiveYonedaObj J ⋙ (forget <| ModuleCat (End J))).PreservesEpimorphisms => _, _⟩
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Functor.PreservesEpimorphisms (yoneda.obj J) ↔ Functor.PreservesEpimorphisms (preadditiveYonedaObj J)

tactic: exact
  Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveYonedaObj J) (forget _)
state_before: case refine'_1
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
h : Functor.PreservesEpimorphisms (preadditiveYonedaObj J ⋙ forget (ModuleCat (End J)))
⊢ Functor.PreservesEpimorphisms (preadditiveYonedaObj J)

tactic: intro
state_before: case refine'_2
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
⊢ Functor.PreservesEpimorphisms (preadditiveYonedaObj J) → Functor.PreservesEpimorphisms (yoneda.obj J)

tactic: exact (inferInstance : (preadditiveYonedaObj J ⋙ forget _).PreservesEpimorphisms)
state_before: case refine'_2
C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
J : C
a✝ : Functor.PreservesEpimorphisms (preadditiveYonedaObj J)
⊢ Functor.PreservesEpimorphisms (yoneda.obj J)
Theorem: MeasureTheory.Memℒp.norm_rpow
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: convert hf.norm_rpow_div p
state_before: α : Type u_2
E : Type u_1
F : Type ?u.729318
G : Type ?u.729321
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => ‖f x‖ ^ ENNReal.toReal p) 1

tactic: rw [div_eq_mul_inv, ENNReal.mul_inv_cancel hp_ne_zero hp_ne_top]
state_before: case h.e'_6
α : Type u_2
E : Type u_1
F : Type ?u.729318
G : Type ?u.729321
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ 1 = p / p
Theorem: Pmf.toMeasure_mono
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: simpa only [p.toMeasure_apply_eq_toOuterMeasure_apply, hs, ht] using toOuterMeasure_mono p h
state_before: α : Type u_1
β : Type ?u.85068
γ : Type ?u.85071
inst✝ : MeasurableSpace α
p : Pmf α
s✝ t✝ s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : s ∩ support p ⊆ t
⊢ ↑↑(toMeasure p) s ≤ ↑↑(toMeasure p) t
Theorem: Matrix.nonsing_inv_eq_ring_inverse
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: by_cases h_det : IsUnit A.det
state_before: l : Type ?u.181457
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ A⁻¹ = Ring.inverse A

tactic: cases (A.isUnit_iff_isUnit_det.mpr h_det).nonempty_invertible
state_before: case pos
l : Type ?u.181457
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h_det : IsUnit (det A)
⊢ A⁻¹ = Ring.inverse A

tactic: rw [← invOf_eq_nonsing_inv, Ring.inverse_invertible]
state_before: case pos.intro
l : Type ?u.181457
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h_det : IsUnit (det A)
val✝ : Invertible A
⊢ A⁻¹ = Ring.inverse A

tactic: have h := mt A.isUnit_iff_isUnit_det.mp h_det
state_before: case neg
l : Type ?u.181457
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h_det : ¬IsUnit (det A)
⊢ A⁻¹ = Ring.inverse A

tactic: rw [Ring.inverse_non_unit _ h, nonsing_inv_apply_not_isUnit A h_det]
state_before: case neg
l : Type ?u.181457
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h_det : ¬IsUnit (det A)
h : ¬IsUnit A
⊢ A⁻¹ = Ring.inverse A
Theorem: Polynomial.X_mul_monomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [X_mul, monomial_mul_X]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
r : R
⊢ X * ↑(monomial n) r = ↑(monomial (n + 1)) r
Theorem: sdiff_sdiff_self
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_sdiff_comm, sdiff_self, bot_sdiff]
state_before: ι : Type ?u.135885
α : Type u_1
β : Type ?u.135891
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a \ b) \ a = ⊥
Theorem: Set.preimage_const_mul_Iio_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Iio_of_neg a h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a c : α
h : c < 0
⊢ (fun x x_1 => x * x_1) c ⁻¹' Iio a = Ioi (a / c)
Theorem: GroupCat.isZero_of_subsingleton
File: Mathlib/Algebra/Category/GroupCat/Zero.lean

tactic: refine' ⟨fun X => ⟨⟨⟨1⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨1⟩, fun f => _⟩⟩⟩
state_before: G : GroupCat
inst✝ : Subsingleton ↑G
⊢ IsZero G

tactic: ext x
state_before: case refine'_1
G : GroupCat
inst✝ : Subsingleton ↑G
X : GroupCat
f : G ⟶ X
⊢ f = default

tactic: have : x = 1 := Subsingleton.elim _ _
state_before: case refine'_1.w
G : GroupCat
inst✝ : Subsingleton ↑G
X : GroupCat
f : G ⟶ X
x : ↑G
⊢ ↑f x = ↑default x

tactic: rw [this, map_one, map_one]
state_before: case refine'_1.w
G : GroupCat
inst✝ : Subsingleton ↑G
X : GroupCat
f : G ⟶ X
x : ↑G
this : x = 1
⊢ ↑f x = ↑default x

tactic: ext
state_before: case refine'_2
G : GroupCat
inst✝ : Subsingleton ↑G
X : GroupCat
f : X ⟶ G
⊢ f = default

tactic: apply Subsingleton.elim
state_before: case refine'_2.w
G : GroupCat
inst✝ : Subsingleton ↑G
X : GroupCat
f : X ⟶ G
x✝ : ↑X
⊢ ↑f x✝ = ↑default x✝
Theorem: PosNum.of_to_nat'
File: Mathlib/Data/Num/Lemmas.lean

tactic: erw [@Num.ofNat'_bit true 0, Num.ofNat'_zero]
state_before: ⊢ Num.ofNat' ↑1 = Num.pos 1

tactic: rfl
state_before: ⊢ cond true Num.bit1 Num.bit0 0 = Num.pos 1

tactic: erw [@Num.ofNat'_bit false, of_to_nat' p]
state_before: p : PosNum
⊢ Num.ofNat' ↑(bit0 p) = Num.pos (bit0 p)

tactic: rfl
state_before: p : PosNum
⊢ cond false Num.bit1 Num.bit0 (Num.pos p) = Num.pos (bit0 p)

tactic: erw [@Num.ofNat'_bit true, of_to_nat' p]
state_before: p : PosNum
⊢ Num.ofNat' ↑(bit1 p) = Num.pos (bit1 p)

tactic: rfl
state_before: p : PosNum
⊢ cond true Num.bit1 Num.bit0 (Num.pos p) = Num.pos (bit1 p)
Theorem: Set.image_sub_const_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Iio b = Iio (b - a)
Theorem: intervalIntegral.norm_integral_le_abs_integral_norm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [← Real.norm_eq_abs, norm_integral_eq_norm_integral_Ioc]
state_before: ι : Type ?u.11937590
𝕜 : Type ?u.11937593
E : Type u_1
F : Type ?u.11937599
A : Type ?u.11937602
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
⊢ ‖∫ (x : ℝ) in a..b, f x ∂μ‖ ≤ abs (∫ (x : ℝ) in a..b, ‖f x‖ ∂μ)

tactic: exact le_trans (norm_integral_le_integral_norm _) (le_abs_self _)
state_before: ι : Type ?u.11937590
𝕜 : Type ?u.11937593
E : Type u_1
F : Type ?u.11937599
A : Type ?u.11937602
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
⊢ ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖ ≤ ‖∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ‖
Theorem: Int.mod_neg
File: Std/Data/Int/DivMod.lean

tactic: rw [mod_def, mod_def, Int.div_neg, Int.neg_mul_neg]
state_before: a b : Int
⊢ mod a (-b) = mod a b
Theorem: ContinuousLinearMap.toSesqForm_apply_norm_le
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: refine' op_norm_le_bound _ (mul_nonneg (norm_nonneg _) (norm_nonneg _)) _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
⊢ ‖↑(↑toSesqForm f) v‖ ≤ ‖f‖ * ‖v‖

tactic: intro x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
⊢ ∀ (x : E), ‖↑(↑(↑toSesqForm f) v) x‖ ≤ ‖f‖ * ‖v‖ * ‖x‖

tactic: have h₁ : ‖f x‖ ≤ ‖f‖ * ‖x‖ := le_op_norm _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
x : E
⊢ ‖↑(↑(↑toSesqForm f) v) x‖ ≤ ‖f‖ * ‖v‖ * ‖x‖

tactic: have h₂ := @norm_inner_le_norm 𝕜 E' _ _ _ v (f x)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
x : E
h₁ : ‖↑f x‖ ≤ ‖f‖ * ‖x‖
⊢ ‖↑(↑(↑toSesqForm f) v) x‖ ≤ ‖f‖ * ‖v‖ * ‖x‖

tactic: calc
  ‖⟪v, f x⟫‖ ≤ ‖v‖ * ‖f x‖ := h₂
  _ ≤ ‖v‖ * (‖f‖ * ‖x‖) := (mul_le_mul_of_nonneg_left h₁ (norm_nonneg v))
  _ = ‖f‖ * ‖v‖ * ‖x‖ := by ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
x : E
h₁ : ‖↑f x‖ ≤ ‖f‖ * ‖x‖
h₂ : ‖inner v (↑f x)‖ ≤ ‖v‖ * ‖↑f x‖
⊢ ‖↑(↑(↑toSesqForm f) v) x‖ ≤ ‖f‖ * ‖v‖ * ‖x‖

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3387427
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : InnerProductSpace 𝕜 E'
f : E →L[𝕜] E'
v : E'
x : E
h₁ : ‖↑f x‖ ≤ ‖f‖ * ‖x‖
h₂ : ‖inner v (↑f x)‖ ≤ ‖v‖ * ‖↑f x‖
⊢ ‖v‖ * (‖f‖ * ‖x‖) = ‖f‖ * ‖v‖ * ‖x‖
Theorem: SimplexCategory.δ_comp_δ''
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: rw [δ_comp_δ]
state_before: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ δ (Fin.castLT i (_ : ↑i < n + 2)) ≫ δ (Fin.succ j) = δ j ≫ δ i

tactic: rfl
state_before: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ δ j ≫ δ (↑Fin.castSucc (Fin.castLT i (_ : ↑i < n + 2))) = δ j ≫ δ i

tactic: exact H
state_before: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ ↑Fin.castSucc j
⊢ Fin.castLT i (_ : ↑i < n + 2) ≤ j
Theorem: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_limit_map
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv,
  limit_map_limitObjIsoLimitCompEvaluation_hom]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
⊢ (limitObjIsoLimitCompEvaluation F i).inv ≫ (limit F).map f =
    limMap (whiskerLeft F ((evaluation K C).map f)) ≫ (limitObjIsoLimitCompEvaluation F j).inv
Theorem: List.getLast!_cons
File: Std/Data/List/Lemmas.lean

tactic: simp [getLast!, getLast_eq_getLastD]
state_before: α : Type u_1
a : α
l : List α
inst✝ : Inhabited α
⊢ getLast! (a :: l) = getLastD l a
Theorem: ChainComplex.single₀_obj_X_dTo
File: Mathlib/Algebra/Homology/Single.lean

tactic: rw [dTo_eq ((single₀ V).obj X) rfl]
state_before: V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ dTo ((single₀ V).obj X) j = 0

tactic: simp
state_before: V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ (xPrevIso ((single₀ V).obj X) (_ : j + 1 = j + 1)).hom ≫ d ((single₀ V).obj X) (j + 1) j = 0