tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Abelian.epi_snd_of_isLimit
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: haveI : Epi (NatTrans.app (limit.cone (cospan f g)).π WalkingCospan.right) :=
  Abelian.epi_pullback_of_epi_f f g
state_before: C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasPullbacks C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : Epi f
s : PullbackCone f g
hs : IsLimit s
⊢ Epi (PullbackCone.snd s)

tactic: apply epi_of_epi_fac (IsLimit.conePointUniqueUpToIso_hom_comp (limit.isLimit _) hs _)
state_before: C : Type u
inst✝³ : Category C
inst✝² : Abelian C
inst✝¹ : HasPullbacks C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : Epi f
s : PullbackCone f g
hs : IsLimit s
this : Epi ((limit.cone (cospan f g)).π.app WalkingCospan.right)
⊢ Epi (PullbackCone.snd s)
Theorem: InnerProductGeometry.angle_add_pos_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle_add_eq_arccos_of_inner_eq_zero h, Real.arccos_pos,
  norm_add_eq_sqrt_iff_real_inner_eq_zero.2 h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
⊢ 0 < angle x (x + y)

tactic: by_cases hx : x = 0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖x‖ / Real.sqrt (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) < 1

tactic: rw [div_lt_one (Real.sqrt_pos.2 (Left.add_pos_of_pos_of_nonneg (mul_self_pos.2
  (norm_ne_zero_iff.2 hx)) (mul_self_nonneg _))), Real.lt_sqrt (norm_nonneg _), pow_two]
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
hx : ¬x = 0
⊢ ‖x‖ / Real.sqrt (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) < 1

tactic: simpa [hx] using h0
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
hx : ¬x = 0
⊢ ‖x‖ * ‖x‖ < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

tactic: simp [hx]
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
hx : x = 0
⊢ ‖x‖ / Real.sqrt (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) < 1
Theorem: Left.mul_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : PosMulStrictMono α
ha : 0 < a
hb : 0 < b
⊢ 0 < a * b
Theorem: Cardinal.zero_power_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: by_cases h : c = 0
state_before: α β : Type u
c : Cardinal
⊢ 0 ^ c ≤ 1

tactic: rw [h, power_zero]
state_before: case pos
α β : Type u
c : Cardinal
h : c = 0
⊢ 0 ^ c ≤ 1

tactic: rw [zero_power h]
state_before: case neg
α β : Type u
c : Cardinal
h : ¬c = 0
⊢ 0 ^ c ≤ 1

tactic: apply zero_le
state_before: case neg
α β : Type u
c : Cardinal
h : ¬c = 0
⊢ 0 ≤ 1
Theorem: Polynomial.Chebyshev.T_eq_U_sub_X_mul_U
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: rw [U_eq_X_mul_U_add_T, add_comm (X * U R n), add_sub_cancel]
state_before: R : Type u_1
S : Type ?u.21238
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ T R (n + 1) = U R (n + 1) - X * U R n
Theorem: List.rdropWhile_last_not
File: Mathlib/Data/List/Rdrop.lean

tactic: simp_rw [rdropWhile]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
hl : rdropWhile p l ≠ []
⊢ ¬p (getLast (rdropWhile p l) hl) = true

tactic: rw [getLast_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
hl : rdropWhile p l ≠ []
⊢ ¬p (getLast (reverse (dropWhile p (reverse l))) (_ : reverse (dropWhile p (reverse l)) ≠ [])) = true

tactic: exact dropWhile_nthLe_zero_not _ _ _
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
hl : rdropWhile p l ≠ []
⊢ ¬p (get (dropWhile p (reverse l)) { val := 0, isLt := (_ : 0 < length (dropWhile p (reverse l))) }) = true
Theorem: UniformGroup.uniformContinuous_iff_open_ker
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: refine' ⟨fun hf => _, fun hf => _⟩
state_before: α : Type u_3
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_1
inst✝⁴ : UniformSpace β
inst✝³ : DiscreteTopology β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
⊢ UniformContinuous ↑f ↔ IsOpen ↑(MonoidHom.ker ↑f)

tactic: apply (isOpen_discrete ({1} : Set β)).preimage hf.continuous
state_before: case refine'_1
α : Type u_3
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_1
inst✝⁴ : UniformSpace β
inst✝³ : DiscreteTopology β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
hf : UniformContinuous ↑f
⊢ IsOpen ↑(MonoidHom.ker ↑f)

tactic: apply uniformContinuous_of_continuousAt_one
state_before: case refine'_2
α : Type u_3
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_1
inst✝⁴ : UniformSpace β
inst✝³ : DiscreteTopology β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
hf : IsOpen ↑(MonoidHom.ker ↑f)
⊢ UniformContinuous ↑f

tactic: rw [ContinuousAt, nhds_discrete β, map_one, tendsto_pure]
state_before: case refine'_2.hf
α : Type u_3
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_1
inst✝⁴ : UniformSpace β
inst✝³ : DiscreteTopology β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
hf : IsOpen ↑(MonoidHom.ker ↑f)
⊢ ContinuousAt (↑f) 1

tactic: exact hf.mem_nhds (map_one f)
state_before: case refine'_2.hf
α : Type u_3
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_1
inst✝⁴ : UniformSpace β
inst✝³ : DiscreteTopology β
inst✝² : Group β
inst✝¹ : UniformGroup β
inst✝ : MonoidHomClass hom α β
f : hom
hf : IsOpen ↑(MonoidHom.ker ↑f)
⊢ ∀ᶠ (x : α) in 𝓝 1, ↑f x = 1
Theorem: MvPolynomial.mem_restrictDegree_iff_sup
File: Mathlib/RingTheory/MvPolynomial/Basic.lean

tactic: simp only [mem_restrictDegree, degrees_def, Multiset.count_finset_sup, Finsupp.count_toMultiset,
  Finset.sup_le_iff]
state_before: σ : Type u
R : Type v
inst✝¹ : CommRing R
p✝ m : ℕ
inst✝ : DecidableEq σ
p : MvPolynomial σ R
n : ℕ
⊢ p ∈ restrictDegree σ R n ↔ ∀ (i : σ), Multiset.count i (degrees p) ≤ n

tactic: exact ⟨fun h n s hs => h s hs n, fun h s hs n => h n s hs⟩
state_before: σ : Type u
R : Type v
inst✝¹ : CommRing R
p✝ m : ℕ
inst✝ : DecidableEq σ
p : MvPolynomial σ R
n : ℕ
⊢ (∀ (s : σ →₀ ℕ), s ∈ support p → ∀ (i : σ), ↑s i ≤ n) ↔ ∀ (i : σ) (b : σ →₀ ℕ), b ∈ support p → ↑b i ≤ n
Theorem: Subspace.dualAnnihilator_dualAnnihilator_eq
File: Mathlib/LinearAlgebra/Dual.lean

tactic: have : _ = W := Subspace.dualAnnihilator_dualCoannihilator_eq
state_before: K : Type u
V : Type v
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
W✝ : Subspace K V
V₁ : Type ?u.1312004
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₁
W : Subspace K V
⊢ dualAnnihilator (dualAnnihilator W) = ↑(Module.mapEvalEquiv K V) W

tactic: rw [dualCoannihilator, ← Module.mapEvalEquiv_symm_apply] at this
state_before: K : Type u
V : Type v
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
W✝ : Subspace K V
V₁ : Type ?u.1312004
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₁
W : Subspace K V
this : dualCoannihilator (dualAnnihilator W) = W
⊢ dualAnnihilator (dualAnnihilator W) = ↑(Module.mapEvalEquiv K V) W

tactic: rwa [← OrderIso.symm_apply_eq]
state_before: K : Type u
V : Type v
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
W✝ : Subspace K V
V₁ : Type ?u.1312004
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₁
W : Subspace K V
this✝ : comap (Module.Dual.eval K V) (dualAnnihilator (dualAnnihilator W)) = W
this : ↑(OrderIso.symm (Module.mapEvalEquiv K V)) (dualAnnihilator (dualAnnihilator W)) = W
⊢ dualAnnihilator (dualAnnihilator W) = ↑(Module.mapEvalEquiv K V) W
Theorem: FractionalIdeal.isFractional_of_fg
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rcases hI with ⟨I, rfl⟩
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.669844
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.670297
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Submodule R P
hI : FG I
⊢ IsFractional S I

tactic: rcases exist_integer_multiples_of_finset S I with ⟨⟨s, hs1⟩, hs⟩
state_before: case intro
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.669844
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.670297
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Finset P
⊢ IsFractional S (span R ↑I)

tactic: rw [isFractional_span_iff]
state_before: case intro.intro.mk
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.669844
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.670297
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Finset P
s : R
hs1 : s ∈ S
hs : ∀ (a : P), a ∈ I → IsInteger R (↑{ val := s, property := hs1 } • a)
⊢ IsFractional S (span R ↑I)

tactic: exact ⟨s, hs1, hs⟩
state_before: case intro.intro.mk
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.669844
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.670297
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Finset P
s : R
hs1 : s ∈ S
hs : ∀ (a : P), a ∈ I → IsInteger R (↑{ val := s, property := hs1 } • a)
⊢ ∃ a, a ∈ S ∧ ∀ (b : P), b ∈ ↑I → IsInteger R (a • b)
Theorem: Filter.frequently_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [frequently_iff_forall_eventually_exists_and, exists_prop, @and_comm (P _)]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.161008
ι : Sort x
f : Filter α
P : α → Prop
⊢ (∃ᶠ (x : α) in f, P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x, x ∈ U ∧ P x

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.161008
ι : Sort x
f : Filter α
P : α → Prop
⊢ (∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, q x ∧ P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x, x ∈ U ∧ P x
Theorem: Nat.bitwise'_comm
File: Mathlib/Data/Nat/Bitwise.lean

tactic: conv_lhs => rw [this]
state_before: f : Bool → Bool → Bool
hf : ∀ (b b' : Bool), f b b' = f b' b
hf' : f false false = false
n m : ℕ
this : bitwise' f = swap (bitwise' f)
⊢ bitwise' f n m = bitwise' f m n
Theorem: ContDiffAt.congr_of_eventuallyEq
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rwa [nhdsWithin_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
hg : f₁ =ᶠ[𝓝 x] f
⊢ f₁ =ᶠ[𝓝[univ] x] f
Theorem: Filter.pi_inf_principal_pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

tactic: rw [← univ_pi_piecewise_univ I, pi_inf_principal_univ_pi_eq_bot]
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f i)
I : Set ι
⊢ pi f ⊓ 𝓟 (Set.pi I s) = ⊥ ↔ ∃ i, i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥

tactic: refine' exists_congr fun i => _
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f i)
I : Set ι
⊢ (∃ i, f i ⊓ 𝓟 (piecewise I s (fun x => univ) i) = ⊥) ↔ ∃ i, i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥

tactic: by_cases hi : i ∈ I <;> simp [hi, NeBot.ne']
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f i)
I : Set ι
i : ι
⊢ f i ⊓ 𝓟 (piecewise I s (fun x => univ) i) = ⊥ ↔ i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥
Theorem: HasFDerivWithinAt.isBigO
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simpa only [sub_add_cancel] using h.isBigO.add (isBigO_sub f' (𝓝[s] x₀) x₀)
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.381155
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.381250
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
s : Set E
x₀ : E
f' : E →L[𝕜] F
h : HasFDerivWithinAt f f' s x₀
⊢ (fun x => f x - f x₀) =O[𝓝[s] x₀] fun x => x - x₀
Theorem: Right.one_lt_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < a⁻¹ ↔ a < 1
Theorem: IntermediateField.adjoin_simple_toSubalgebra_of_integral
File: Mathlib/FieldTheory/Adjoin.lean

tactic: apply adjoin_algebraic_toSubalgebra
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
hα : IsIntegral F α
⊢ F⟮α⟯.toSubalgebra = Algebra.adjoin F {α}

tactic: rintro x (rfl : x = α)
state_before: case hS
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
hα : IsIntegral F α
⊢ ∀ (x : E), x ∈ Insert.insert ∅ α → IsAlgebraic F x

tactic: rwa [isAlgebraic_iff_isIntegral]
state_before: case hS
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
hα : IsIntegral F x
⊢ IsAlgebraic F x
Theorem: Function.support_mul_subset_left
File: Mathlib/Algebra/Support.lean

tactic: simp only [hf, zero_mul]
state_before: α : Type u_2
β : Type ?u.84556
A : Type ?u.84559
B : Type ?u.84562
M : Type ?u.84565
N : Type ?u.84568
P : Type ?u.84571
R : Type u_1
S : Type ?u.84577
G : Type ?u.84580
M₀ : Type ?u.84583
G₀ : Type ?u.84586
ι : Sort ?u.84589
inst✝ : MulZeroClass R
f g : α → R
x : α
hfg : x ∈ support fun x => f x * g x
hf : f x = 0
⊢ (fun x => f x * g x) x = 0
Theorem: QuaternionAlgebra.coe_add
File: Mathlib/Algebra/Quaternion.lean

tactic: ext <;> simp
state_before: S : Type ?u.24395
T : Type ?u.24398
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ ↑(x + y) = ↑x + ↑y
Theorem: Int.norm_cast_rat
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← Rat.norm_cast_real, ← Int.norm_cast_real]
state_before: 𝓕 : Type ?u.1114918
𝕜 : Type ?u.1114921
α : Type ?u.1114924
ι : Type ?u.1114927
κ : Type ?u.1114930
E : Type ?u.1114933
F : Type ?u.1114936
G : Type ?u.1114939
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : ℤ
⊢ ‖↑m‖ = ‖m‖

tactic: congr 1
state_before: 𝓕 : Type ?u.1114918
𝕜 : Type ?u.1114921
α : Type ?u.1114924
ι : Type ?u.1114927
κ : Type ?u.1114930
E : Type ?u.1114933
F : Type ?u.1114936
G : Type ?u.1114939
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
m : ℤ
⊢ ‖↑↑m‖ = ‖↑m‖
Theorem: skewAdjoint.isStarNormal_of_mem
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [mem_iff] at hx
state_before: R : Type u_1
A : Type ?u.113647
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
⊢ Commute (star x) x

tactic: simp only [hx, Commute.neg_left, Commute.refl]
state_before: R : Type u_1
A : Type ?u.113647
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : star x = -x
⊢ Commute (star x) x
Theorem: cardinal_le_rank_of_linearIndependent
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa using cardinal_lift_le_rank_of_linearIndependent hv
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.106262
R : Type u
inst✝⁷ : Ring R
M : Type v
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type v'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
M₁ : Type v
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Nontrivial R
ι : Type v
v : ι → M
hv : LinearIndependent R v
⊢ (#ι) ≤ Module.rank R M
Theorem: CategoryTheory.Subobject.eq_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝² : Category C
X✝ Y Z : C
D : Type u₂
inst✝¹ : Category D
B A : C
X : Subobject B
f : A ⟶ B
inst✝ : Mono f
i : underlying.obj X ≅ A
w : i.hom ≫ f = arrow X
⊢ (i ≪≫ (underlyingIso f).symm).hom ≫ arrow (mk f) = arrow X
Theorem: Cardinal.card_typein_out_lt
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← lt_ord]
state_before: α : Type ?u.230240
β : Type ?u.230243
γ : Type ?u.230246
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
x : (Quotient.out (ord c)).α
⊢ card (typein (fun x x_1 => x < x_1) x) < c

tactic: apply typein_lt_self
state_before: α : Type ?u.230240
β : Type ?u.230243
γ : Type ?u.230246
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal
x : (Quotient.out (ord c)).α
⊢ typein (fun x x_1 => x < x_1) x < ord c
Theorem: Set.Icc.one_sub_le_one
File: Mathlib/Data/Set/Intervals/Instances.lean

tactic: simpa using x.2.1
state_before: α : Type ?u.28279
inst✝¹ : OrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
x : ↑(Icc 0 1)
⊢ 1 - ↑x ≤ 1
Theorem: TendstoUniformlyOn.seq_tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendsto] at h⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
h : TendstoUniformlyOn F f l s
u : ℕ → ι
hu : Tendsto u atTop l
⊢ TendstoUniformlyOn (fun n => F (u n)) f atTop s

tactic: exact h.comp ((hu.comp tendsto_fst).prod_mk tendsto_snd)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
l : Filter ι
h : Tendsto (fun q => (f q.snd, F q.fst q.snd)) (l ×ˢ 𝓟 s) (𝓤 β)
u : ℕ → ι
hu : Tendsto u atTop l
⊢ Tendsto (fun q => (f q.snd, F (u q.fst) q.snd)) (atTop ×ˢ 𝓟 s) (𝓤 β)
Theorem: ENNReal.mul_iInf
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [mul_comm] using iInf_mul h
state_before: α : Type ?u.867446
β : Type ?u.867449
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι✝ : Sort ?u.867466
f✝ g : ι✝ → ℝ≥0∞
ι : Sort u_1
inst✝ : Nonempty ι
f : ι → ℝ≥0∞
x : ℝ≥0∞
h : x ≠ ⊤
⊢ x * iInf f = ⨅ (i : ι), x * f i
Theorem: Ideal.IsHomogeneous.bot
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp only [Ideal.mem_bot] at hr
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.113854
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
i : ι
r : A
hr : r ∈ ⊥
⊢ ↑(↑(↑(decompose 𝒜) r) i) ∈ ⊥

tactic: rw [hr, decompose_zero, zero_apply]
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.113854
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
i : ι
r : A
hr : r = 0
⊢ ↑(↑(↑(decompose 𝒜) r) i) ∈ ⊥

tactic: apply Ideal.zero_mem
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.113854
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
i : ι
r : A
hr : r = 0
⊢ ↑0 ∈ ⊥
Theorem: sup_himp_bihimp
File: Mathlib/Order/SymmDiff.lean

tactic: rw [himp_bihimp]
state_before: ι : Type ?u.45477
α : Type u_1
β : Type ?u.45483
π : ι → Type ?u.45488
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⊔ b ⇨ a ⇔ b = a ⇔ b

tactic: simp [bihimp]
state_before: ι : Type ?u.45477
α : Type u_1
β : Type ?u.45483
π : ι → Type ?u.45488
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ ((a ⊔ b) ⊓ b ⇨ a) ⊓ ((a ⊔ b) ⊓ a ⇨ b) = a ⇔ b
Theorem: zero_eq_mul
File: Mathlib/Algebra/GroupWithZero/Defs.lean

tactic: rw [eq_comm, mul_eq_zero]
state_before: G₀ : Type u
M₀ : Type u_1
M₀' : Type ?u.10888
G₀' : Type ?u.10891
inst✝¹ : MulZeroClass M₀
inst✝ : NoZeroDivisors M₀
a b : M₀
⊢ 0 = a * b ↔ a = 0 ∨ b = 0
Theorem: Ideal.ramificationIdx_eq_zero
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: push_neg
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ∀ (n : ℕ), ∃ k, map f p ≤ P ^ k ∧ n < k
⊢ ¬∃ n, ∀ (a : ℕ), a ∈ {n | map f p ≤ P ^ n} → a ≤ n

tactic: exact h
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ∀ (n : ℕ), ∃ k, map f p ≤ P ^ k ∧ n < k
⊢ ∀ (n : ℕ), ∃ a, a ∈ {n | map f p ≤ P ^ n} ∧ n < a
Theorem: norm_image_sub_le_of_norm_deriv_le_segment_01'
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [sub_zero, mul_one] using
  norm_image_sub_le_of_norm_deriv_le_segment' hf bound 1 (right_mem_Icc.2 zero_le_one)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.42710
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' : ℝ → E
C : ℝ
hf : ∀ (x : ℝ), x ∈ Icc 0 1 → HasDerivWithinAt f (f' x) (Icc 0 1) x
bound : ∀ (x : ℝ), x ∈ Ico 0 1 → ‖f' x‖ ≤ C
⊢ ‖f 1 - f 0‖ ≤ C
Theorem: Finset.Nat.prod_antidiagonal_subst
File: Mathlib/Algebra/BigOperators/NatAntidiagonal.lean

tactic: rw [Nat.mem_antidiagonal.1 hp]
state_before: M : Type u_1
N : Type ?u.9475
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → ℕ → M
p : ℕ × ℕ
hp : p ∈ antidiagonal n
⊢ f p n = f p (p.fst + p.snd)
Theorem: MonoidAlgebra.of_injective
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simpa using (single_eq_single_iff _ _ _ _).mp h
state_before: k : Type u₁
G : Type u₂
R : Type ?u.478651
inst✝² : Semiring k
inst✝¹ : MulOneClass G
inst✝ : Nontrivial k
a b : G
h : ↑(of k G) a = ↑(of k G) b
⊢ a = b
Theorem: TopCat.stalkToFiber_germ
File: Mathlib/Topology/Sheaves/LocalPredicate.lean

tactic: dsimp [Presheaf.germ, stalkToFiber]
state_before: X : TopCat
T : ↑X → Type v
P : LocalPredicate T
U : Opens ↑X
x : { x // x ∈ U }
f : (Sheaf.presheaf (subsheafToTypes P)).obj U.op
⊢ stalkToFiber P (↑x) (Presheaf.germ (Sheaf.presheaf (subsheafToTypes P)) x f) = ↑f x

tactic: cases x
state_before: X : TopCat
T : ↑X → Type v
P : LocalPredicate T
U : Opens ↑X
x : { x // x ∈ U }
f : (Sheaf.presheaf (subsheafToTypes P)).obj U.op
⊢ colimit.desc (Functor.op (OpenNhds.inclusion ↑x) ⋙ subpresheafToTypes P.toPrelocalPredicate)
      { pt := T ↑x, ι := NatTrans.mk fun U_1 f => ↑f { val := ↑x, property := (_ : ↑x ∈ U_1.unop.obj) } }
      (colimit.ι (Functor.op (OpenNhds.inclusion ↑x) ⋙ subpresheafToTypes P.toPrelocalPredicate)
        { obj := U, property := (_ : ↑x ∈ U) }.op f) =
    ↑f x

tactic: simp
state_before: case mk
X : TopCat
T : ↑X → Type v
P : LocalPredicate T
U : Opens ↑X
f : (Sheaf.presheaf (subsheafToTypes P)).obj U.op
val✝ : ↑X
property✝ : val✝ ∈ U
⊢ colimit.desc
      (Functor.op (OpenNhds.inclusion ↑{ val := val✝, property := property✝ }) ⋙
        subpresheafToTypes P.toPrelocalPredicate)
      { pt := T ↑{ val := val✝, property := property✝ },
        ι :=
          NatTrans.mk fun U_1 f =>
            ↑f
              { val := ↑{ val := val✝, property := property✝ },
                property := (_ : ↑{ val := val✝, property := property✝ } ∈ U_1.unop.obj) } }
      (colimit.ι
        (Functor.op (OpenNhds.inclusion ↑{ val := val✝, property := property✝ }) ⋙
          subpresheafToTypes P.toPrelocalPredicate)
        { obj := U, property := (_ : ↑{ val := val✝, property := property✝ } ∈ U) }.op f) =
    ↑f { val := val✝, property := property✝ }