tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.MonoCoprod.mono_inl_iff
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

tactic: suffices
  ∀ (c₁ c₂ : BinaryCofan A B) (_ : IsColimit c₁) (_ : IsColimit c₂) (_ : Mono c₁.inl),
    Mono c₂.inl
  by exact ⟨fun h₁ => this _ _ hc₁ hc₂ h₁, fun h₂ => this _ _ hc₂ hc₁ h₂⟩
state_before: C : Type u_2
inst✝ : Category C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ Mono (BinaryCofan.inl c₁) ↔ Mono (BinaryCofan.inl c₂)

tactic: intro c₁ c₂ hc₁ hc₂
state_before: C : Type u_2
inst✝ : Category C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ ∀ (c₁ c₂ : BinaryCofan A B), IsColimit c₁ → IsColimit c₂ → Mono (BinaryCofan.inl c₁) → Mono (BinaryCofan.inl c₂)

tactic: intro
state_before: C : Type u_2
inst✝ : Category C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
⊢ Mono (BinaryCofan.inl c₁) → Mono (BinaryCofan.inl c₂)

tactic: simpa only [IsColimit.comp_coconePointUniqueUpToIso_hom] using
  mono_comp c₁.inl (hc₁.coconePointUniqueUpToIso hc₂).hom
state_before: C : Type u_2
inst✝ : Category C
A B : C
c₁✝ c₂✝ : BinaryCofan A B
hc₁✝ : IsColimit c₁✝
hc₂✝ : IsColimit c₂✝
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
x✝ : Mono (BinaryCofan.inl c₁)
⊢ Mono (BinaryCofan.inl c₂)

tactic: exact ⟨fun h₁ => this _ _ hc₁ hc₂ h₁, fun h₂ => this _ _ hc₂ hc₁ h₂⟩
state_before: C : Type u_2
inst✝ : Category C
A B : C
c₁ c₂ : BinaryCofan A B
hc₁ : IsColimit c₁
hc₂ : IsColimit c₂
this : ∀ (c₁ c₂ : BinaryCofan A B), IsColimit c₁ → IsColimit c₂ → Mono (BinaryCofan.inl c₁) → Mono (BinaryCofan.inl c₂)
⊢ Mono (BinaryCofan.inl c₁) ↔ Mono (BinaryCofan.inl c₂)
Theorem: SimpleGraph.Walk.IsPath.reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa [isPath_def] using h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
h : IsPath p
⊢ IsPath (Walk.reverse p)
Theorem: Quaternion.sq_eq_neg_normSq
File: Mathlib/Algebra/Quaternion.lean

tactic: simp_rw [← star_eq_neg]
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ a ^ 2 = -↑(↑normSq a) ↔ a.re = 0

tactic: obtain rfl | hq0 := eq_or_ne a 0
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ a ^ 2 = -↑(↑normSq a) ↔ star a = -a

tactic: simp
state_before: case inl
R : Type u_1
inst✝ : LinearOrderedCommRing R
⊢ 0 ^ 2 = -↑(↑normSq 0) ↔ star 0 = -0

tactic: rw [← star_mul_self, ← mul_neg, ← neg_sq, sq, mul_left_inj' (neg_ne_zero.mpr hq0), eq_comm]
state_before: case inr
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
hq0 : a ≠ 0
⊢ a ^ 2 = -↑(↑normSq a) ↔ star a = -a
Theorem: MeasurableEmbedding.map_comap
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 t ht
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.911558
δ : Type ?u.911561
ι : Type ?u.911564
R : Type ?u.911567
R' : Type ?u.911570
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : MeasureTheory.Measure β
⊢ Measure.map f (Measure.comap f μ) = Measure.restrict μ (range f)

tactic: rw [hf.map_apply, comap_apply f hf.injective hf.measurableSet_image' _ (hf.measurable ht),
  image_preimage_eq_inter_range, Measure.restrict_apply ht]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.911558
δ : Type ?u.911561
ι : Type ?u.911564
R : Type ?u.911567
R' : Type ?u.911570
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : MeasureTheory.Measure β
t : Set β
ht : MeasurableSet t
⊢ ↑↑(Measure.map f (Measure.comap f μ)) t = ↑↑(Measure.restrict μ (range f)) t
Theorem: Complex.ofReal_sin_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ ↑(starRingEnd ℂ) (sin ↑x) = sin ↑x
Theorem: IsSelfAdjoint.star_mul_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [IsSelfAdjoint, star_mul, star_star]
state_before: R : Type u_1
A : Type ?u.712
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x : R
⊢ IsSelfAdjoint (star x * x)
Theorem: MeasurableSet.congr
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rwa [← h]
state_before: α : Type u_1
β : Type ?u.3804
γ : Type ?u.3807
δ : Type ?u.3810
δ' : Type ?u.3813
ι : Sort ?u.3816
s✝ t✝ u : Set α
m : MeasurableSpace α
s t : Set α
hs : MeasurableSet s
h : s = t
⊢ MeasurableSet t
Theorem: pow_mem_ball
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h⊢
state_before: 𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : a ∈ ball b r
⊢ a ^ n ∈ ball (b ^ n) (n • r)

tactic: refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
state_before: 𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ‖(a / b) ^ n‖ < n • r

tactic: replace hn : 0 < (n : ℝ)
state_before: 𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ↑n * ‖a / b‖ < n • r

tactic: rw [nsmul_eq_mul]
state_before: 𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < n • r

tactic: nlinarith
state_before: 𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < ↑n * r

tactic: norm_cast
state_before: case hn
𝓕 : Type ?u.915521
𝕜 : Type ?u.915524
α : Type ?u.915527
ι : Type ?u.915530
κ : Type ?u.915533
E : Type u_1
F : Type ?u.915539
G : Type ?u.915542
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ 0 < ↑n
Theorem: HasDerivAtFilter.congr_of_eventuallyEq
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: rwa [hL.hasDerivAtFilter_iff hx rfl]
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 𝕜
h : HasDerivAtFilter f f' x L
hL : f₁ =ᶠ[L] f
hx : f₁ x = f x
⊢ HasDerivAtFilter f₁ f' x L
Theorem: MeasureTheory.SimpleFunc.nearestPtInd_le
File: Mathlib/MeasureTheory/Function/SimpleFuncDense.lean

tactic: induction' N with N ihN
state_before: α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
N : ℕ
x : α
⊢ ↑(nearestPtInd e N) x ≤ N

tactic: simp only [nearestPtInd_succ]
state_before: case succ
α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
x : α
N : ℕ
ihN : ↑(nearestPtInd e N) x ≤ N
⊢ ↑(nearestPtInd e (Nat.succ N)) x ≤ Nat.succ N

tactic: split_ifs
state_before: case succ
α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
x : α
N : ℕ
ihN : ↑(nearestPtInd e N) x ≤ N
⊢ (if ∀ (k : ℕ), k ≤ N → edist (e (N + 1)) x < edist (e k) x then N + 1 else ↑(nearestPtInd e N) x) ≤ Nat.succ N

tactic: exacts [le_rfl, ihN.trans N.le_succ]
state_before: case succ.inl
α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
x : α
N : ℕ
ihN : ↑(nearestPtInd e N) x ≤ N
h✝ : ∀ (k : ℕ), k ≤ N → edist (e (N + 1)) x < edist (e k) x
⊢ N + 1 ≤ Nat.succ N

case succ.inr
α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
x : α
N : ℕ
ihN : ↑(nearestPtInd e N) x ≤ N
h✝ : ¬∀ (k : ℕ), k ≤ N → edist (e (N + 1)) x < edist (e k) x
⊢ ↑(nearestPtInd e N) x ≤ Nat.succ N

tactic: simp
state_before: case zero
α : Type u_1
β : Type ?u.23173
ι : Type ?u.23176
E : Type ?u.23179
F : Type ?u.23182
𝕜 : Type ?u.23185
inst✝² : MeasurableSpace α
inst✝¹ : PseudoEMetricSpace α
inst✝ : OpensMeasurableSpace α
e : ℕ → α
x : α
⊢ ↑(nearestPtInd e Nat.zero) x ≤ Nat.zero
Theorem: Real.rpow_pos_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_def_of_pos hx]
state_before: x : ℝ
hx : 0 < x
y : ℝ
⊢ 0 < x ^ y

tactic: apply exp_pos
state_before: x : ℝ
hx : 0 < x
y : ℝ
⊢ 0 < exp (log x * y)
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: simp only [Fin.not_lt_zero, hi] at H
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
hi : i = 0
⊢ False

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ δ X i ≫ σ X j = σ X (Fin.castLT j (_ : ↑j < n + 1)) ≫ δ X (Fin.pred i (_ : i = 0 → False))

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt' H]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ (Fin.castLT j (_ : ↑j < n + 1))) ≫
      X.map (SimplexCategory.δ (Fin.pred i (_ : i = 0 → False)))
Theorem: card_eq_pow_finrank
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: let b := IsNoetherian.finsetBasis K V
state_before: K : Type u_2
R : Type ?u.998574
V : Type u_1
inst✝⁴ : Fintype K
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Fintype V
⊢ Fintype.card V = q ^ FiniteDimensional.finrank K V

tactic: rw [Module.card_fintype b, ← FiniteDimensional.finrank_eq_card_basis b]
state_before: K : Type u_2
R : Type ?u.998574
V : Type u_1
inst✝⁴ : Fintype K
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Fintype V
b : Basis { x // x ∈ IsNoetherian.finsetBasisIndex K V } K V := IsNoetherian.finsetBasis K V
⊢ Fintype.card V = q ^ FiniteDimensional.finrank K V
Theorem: Real.sinh_sub_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← neg_sub, cosh_sub_sinh]
state_before: x y : ℝ
⊢ sinh x - cosh x = -exp (-x)
Theorem: Nat.unpair_right_le
File: Mathlib/Data/Nat/Pairing.lean

tactic: simpa using right_le_pair n.unpair.1 n.unpair.2
state_before: n : ℕ
⊢ (unpair n).snd ≤ n
Theorem: newton_seq_dist_aux
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [T_pow_nonneg, mul_nonneg]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ ‖newton_seq (n + 0) - newton_seq n‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n

tactic: apply pow_le_pow
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
⊢ 2 ^ n ≤ 2 ^ (n + k)

tactic: norm_num
state_before: case ha
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
⊢ 1 ≤ 2

case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
⊢ n ≤ n + k

tactic: apply Nat.le_add_right
state_before: case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
⊢ n ≤ n + k

tactic: rw [add_assoc]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
this : 2 ^ n ≤ 2 ^ (n + k)
⊢ ‖newton_seq (n + (k + 1)) - newton_seq n‖ = ‖newton_seq (n + k + 1) - newton_seq n‖

tactic: rw [← sub_add_sub_cancel]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n k : ℕ
this : 2 ^ n ≤ 2 ^ (n + k)
⊢ ‖newton_seq (n + k + 1) - newton_seq n‖ =
    ‖newton_seq (n + k + 1) - newton_seq (n + k) + (newton_seq (n + k) - newton_seq n)‖
Theorem: Matrix.vecMul_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [← vecMul_vecMul, vecMul_transpose]
state_before: l : Type ?u.919751
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.919765
n' : o → Type ?u.919770
R : Type ?u.919773
S : Type ?u.919776
α : Type v
β : Type w
γ : Type ?u.919783
inst✝² : NonUnitalCommSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
A : Matrix m n α
B : Matrix m o α
x : n → α
⊢ vecMul (mulVec A x) B = vecMul x (Aᵀ ⬝ B)
Theorem: Polynomial.prime_X_sub_C
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp_rw [dvd_iff_isRoot, IsRoot.def, eval_mul, mul_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
r : R
x✝¹ x✝ : R[X]
⊢ X - ↑C r ∣ x✝¹ * x✝ → X - ↑C r ∣ x✝¹ ∨ X - ↑C r ∣ x✝

tactic: exact id
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
r : R
x✝¹ x✝ : R[X]
⊢ eval r x✝¹ = 0 ∨ eval r x✝ = 0 → eval r x✝¹ = 0 ∨ eval r x✝ = 0
Theorem: FractionalIdeal.spanSingleton_one
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: ext
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1331786
inst✝³ : CommRing R₁
K : Type ?u.1331792
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
⊢ spanSingleton S 1 = 1

tactic: refine' (mem_spanSingleton S).trans ((exists_congr _).trans (mem_one_iff S).symm)
state_before: case a
R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1331786
inst✝³ : CommRing R₁
K : Type ?u.1331792
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ x✝ ∈ spanSingleton S 1 ↔ x✝ ∈ 1

tactic: intro x'
state_before: case a
R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1331786
inst✝³ : CommRing R₁
K : Type ?u.1331792
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ ∀ (a : R), a • 1 = x✝ ↔ ↑(algebraMap R P) a = x✝

tactic: rw [Algebra.smul_def, mul_one]
state_before: case a
R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1331786
inst✝³ : CommRing R₁
K : Type ?u.1331792
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
x' : R
⊢ x' • 1 = x✝ ↔ ↑(algebraMap R P) x' = x✝
Theorem: Filter.tendsto_pow_atTop_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [hn, pow_zero, not_tendsto_const_atTop] at h
state_before: ι : Type ?u.210440
ι' : Type ?u.210443
α : Type u_1
β : Type ?u.210449
γ : Type ?u.210452
inst✝ : LinearOrderedSemiring α
l : Filter β
f : β → α
n : ℕ
h : Tendsto (fun x => x ^ n) atTop atTop
hn : n = 0
⊢ False
Theorem: MeasureTheory.hasFiniteIntegral_iff_edist
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [hasFiniteIntegral_iff_norm, edist_dist, dist_zero_right]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.700144
δ : Type ?u.700147
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ HasFiniteIntegral f ↔ (∫⁻ (a : α), edist (f a) 0 ∂μ) < ⊤
Theorem: discrim_lt_zero
File: Mathlib/Algebra/QuadraticDiscriminant.lean

tactic: have : ∀ x : K, 0 ≤ a * x * x + b * x + c := fun x => le_of_lt (h x)
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
⊢ discrim a b c < 0

tactic: refine lt_of_le_of_ne (discrim_le_zero this) fun h' ↦ ?_
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
this : ∀ (x : K), 0 ≤ a * x * x + b * x + c
⊢ discrim a b c < 0

tactic: have := h (-b / (2 * a))
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
this : ∀ (x : K), 0 ≤ a * x * x + b * x + c
h' : discrim a b c = 0
⊢ False

tactic: have : a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c = 0 := by
  rw [quadratic_eq_zero_iff_of_discrim_eq_zero ha h' (-b / (2 * a))]
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
this✝ : ∀ (x : K), 0 ≤ a * x * x + b * x + c
h' : discrim a b c = 0
this : 0 < a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c
⊢ False

tactic: linarith
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
this✝¹ : ∀ (x : K), 0 ≤ a * x * x + b * x + c
h' : discrim a b c = 0
this✝ : 0 < a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c
this : a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c = 0
⊢ False

tactic: rw [quadratic_eq_zero_iff_of_discrim_eq_zero ha h' (-b / (2 * a))]
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), 0 < a * x * x + b * x + c
this✝ : ∀ (x : K), 0 ≤ a * x * x + b * x + c
h' : discrim a b c = 0
this : 0 < a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c
⊢ a * (-b / (2 * a)) * (-b / (2 * a)) + b * (-b / (2 * a)) + c = 0
Theorem: IsROrC.re_eq_norm_of_mul_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [mul_conj, ofReal_re, norm_ofReal, abs_of_nonneg (normSq_nonneg _)]
state_before: K : Type u_1
E : Type ?u.6950633
inst✝ : IsROrC K
x : K
⊢ ↑re (x * ↑(starRingEnd K) x) = ‖x * ↑(starRingEnd K) x‖
Theorem: symmDiff_eq_iff_sdiff_eq
File: Mathlib/Order/SymmDiff.lean

tactic: rw [← symmDiff_of_le ha]
state_before: ι : Type ?u.78168
α : Type u_1
β : Type ?u.78174
π : ι → Type ?u.78179
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : a ≤ c
⊢ a ∆ b = c ↔ c \ a = b

tactic: exact ((symmDiff_right_involutive a).toPerm _).apply_eq_iff_eq_symm_apply.trans eq_comm
state_before: ι : Type ?u.78168
α : Type u_1
β : Type ?u.78174
π : ι → Type ?u.78179
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
ha : a ≤ c
⊢ a ∆ b = c ↔ a ∆ c = b
Theorem: Basis.prod_apply_inr_fst
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext i
state_before: ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.573115
K : Type ?u.573118
M : Type u_1
M' : Type u_2
M'' : Type ?u.573127
V : Type u
V' : Type ?u.573132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι'
⊢ ↑b.repr (↑(Basis.prod b b') (Sum.inr i)).fst = ↑b.repr 0

tactic: simp only [Basis.prod, Basis.coe_ofRepr, LinearEquiv.symm_trans_apply, LinearEquiv.prod_symm,
  LinearEquiv.prod_apply, b.repr.apply_symm_apply, LinearEquiv.symm_symm, repr_self,
  Equiv.toFun_as_coe, Finsupp.fst_sumFinsuppLEquivProdFinsupp, LinearEquiv.map_zero,
  Finsupp.zero_apply]
state_before: case h
ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.573115
K : Type ?u.573118
M : Type u_1
M' : Type u_2
M'' : Type ?u.573127
V : Type u
V' : Type ?u.573132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝¹ : ι
c : R
x : M
b' : Basis ι' R M'
i✝ : ι'
i : ι
⊢ ↑(↑b.repr (↑(Basis.prod b b') (Sum.inr i✝)).fst) i = ↑(↑b.repr 0) i

tactic: apply Finsupp.single_eq_of_ne Sum.inr_ne_inl
state_before: case h
ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.573115
K : Type ?u.573118
M : Type u_1
M' : Type u_2
M'' : Type ?u.573127
V : Type u
V' : Type ?u.573132
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝¹ : ι
c : R
x : M
b' : Basis ι' R M'
i✝ : ι'
i : ι
⊢ ↑(Finsupp.single (Sum.inr i✝) 1) (Sum.inl i) = 0
Theorem: Finset.preimage_mul_right_one
File: Mathlib/Data/Finset/Pointwise.lean

tactic: classical rw [← image_mul_right', image_one, one_mul]
state_before: F : Type ?u.679577
α : Type u_1
β : Type ?u.679583
γ : Type ?u.679586
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage 1 (fun x => x * b) (_ : Set.InjOn (fun x => x * b) ((fun x => x * b) ⁻¹' ↑1)) = {b⁻¹}

tactic: rw [← image_mul_right', image_one, one_mul]
state_before: F : Type ?u.679577
α : Type u_1
β : Type ?u.679583
γ : Type ?u.679586
inst✝ : Group α
s t : Finset α
a b : α
⊢ preimage 1 (fun x => x * b) (_ : Set.InjOn (fun x => x * b) ((fun x => x * b) ⁻¹' ↑1)) = {b⁻¹}
Theorem: Polynomial.bit0_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [bit0, add_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (bit0 p) q = bit0 (comp p q)
Theorem: Metric.isBounded_iff_nndist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [isBounded_iff_exists_ge 0, NNReal.exists, ← NNReal.coe_le_coe, ← dist_nndist,
  NNReal.coe_mk, exists_prop]
state_before: α : Type u
β : Type v
X : Type ?u.47942
ι : Type ?u.47945
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
⊢ IsBounded s ↔ ∃ C, ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → nndist x y ≤ C
Theorem: Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sign_nonneg_iff]
state_before: θ : ℝ
h0 : 0 ≤ θ
hpi : θ ≤ π
⊢ 0 ≤ sign ↑θ

tactic: exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
state_before: θ : ℝ
h0 : 0 ≤ θ
hpi : θ ≤ π
⊢ 0 ≤ sin ↑θ
Theorem: MeasureTheory.OuterMeasure.boundedBy_zero
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [← coe_bot, eq_bot_iff]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
⊢ boundedBy 0 = 0

tactic: apply boundedBy_le
state_before: α : Type u_1
m : Set α → ℝ≥0∞
⊢ boundedBy 0 ≤ ⊥
Theorem: WithTop.add_coe_eq_top_iff
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: induction x using WithTop.recTopCoe <;> simp [← coe_add]
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x✝ y✝ : α
x : WithTop α
y : α
⊢ x + ↑y = ⊤ ↔ x = ⊤
Theorem: List.nthLe_insertNth_self
File: Mathlib/Data/List/Basic.lean

tactic: rwa [length_insertNth _ _ hn, Nat.lt_succ_iff]
state_before: ι : Type ?u.126707
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
x : α
n : ℕ
hn : n ≤ length l
⊢ n < length (insertNth n x l)