tasksource/leandojo huggingface dataset:
Theorem: Ordinal.log_mod_opow_log_lt_log_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: cases' eq_or_ne (o % (b^log b o)) 0 with h h
state_before: b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
⊢ log b (o % b ^ log b o) < log b o

tactic: rw [h, log_zero_right]
state_before: case inl
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ log b (o % b ^ log b o) < log b o

tactic: apply log_pos hb ho hbo
state_before: case inl
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ 0 < log b o

tactic: rw [← succ_le_iff, succ_log_def hb h]
state_before: case inr
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b (o % b ^ log b o) < log b o

tactic: apply csInf_le'
state_before: case inr
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ sInf {o_1 | o % b ^ log b o < b ^ o_1} ≤ log b o

tactic: apply mod_lt
state_before: case inr.h
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b o ∈ {o_1 | o % b ^ log b o < b ^ o_1}

tactic: rw [← Ordinal.pos_iff_ne_zero]
state_before: case inr.h.h
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ b ^ log b o ≠ 0

tactic: exact opow_pos _ (zero_lt_one.trans hb)
state_before: case inr.h.h
b o : Ordinal
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ 0 < b ^ log b o
Theorem: SatisfiesM.map
File: Std/Classes/LawfulMonad.lean

tactic: let ⟨x', hx⟩ := hx
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
⊢ SatisfiesM q (f <$> x)

tactic: refine ⟨(fun ⟨a, h⟩ => ⟨f a, hf h⟩) <$> x', ?_⟩
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ SatisfiesM q (f <$> x)

tactic: rw [← hx]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | { val := a, property := h } => { val := f a, property := (_ : q (f a)) }) <$>
        x' =
    f <$> x

tactic: simp [← comp_map, Function.comp]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | { val := a, property := h } => { val := f a, property := (_ : q (f a)) }) <$>
        x' =
    f <$> Subtype.val <$> x'
Theorem: NNReal.sqrt_mul
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt_eq_iff_sq_eq, mul_pow, sq_sqrt, sq_sqrt]
state_before: x✝ y✝ x y : ℝ≥0
⊢ ↑sqrt (x * y) = ↑sqrt x * ↑sqrt y
Theorem: ADEInequality.admissible_of_one_lt_sumInv_aux
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: obtain ⟨⟨hpq, -⟩, hqr⟩ : (p ≤ q ∧ p ≤ r) ∧ q ≤ r
state_before: p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : List.length [p, q, r] = 3
H : 1 < sumInv ↑[p, q, r]
⊢ Admissible ↑[p, q, r]

tactic: simpa using hs
state_before: p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : List.length [p, q, r] = 3
H : 1 < sumInv ↑[p, q, r]
⊢ (p ≤ q ∧ p ≤ r) ∧ q ≤ r

case intro.intro
p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : List.length [p, q, r] = 3
H : 1 < sumInv ↑[p, q, r]
hqr : q ≤ r
hpq : p ≤ q
⊢ Admissible ↑[p, q, r]

tactic: exact admissible_of_one_lt_sumInv_aux' hpq hqr H
state_before: case intro.intro
p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : List.length [p, q, r] = 3
H : 1 < sumInv ↑[p, q, r]
hqr : q ≤ r
hpq : p ≤ q
⊢ Admissible ↑[p, q, r]
Theorem: List.foldr_join
File: Mathlib/Data/List/Basic.lean

tactic: simp only [join, foldr_append, foldr_join f a L, foldr_cons]
state_before: ι : Type ?u.232055
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
a : β
l : List α
L : List (List α)
⊢ foldr f a (join (l :: L)) = foldr (fun l b => foldr f b l) a (l :: L)
Theorem: ModuleCat.MonoidalCategory.triangle
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

tactic: apply TensorProduct.ext_threefold
state_before: R : Type u
inst✝ : CommRing R
M N : ModuleCat R
⊢ (associator M (of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom = tensorHom (rightUnitor M).hom (𝟙 N)

tactic: intro x y z
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
⊢ ∀ (x : ↑M) (y : ↑(of R R)) (z : ↑N),
    ↑((associator M (of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
      ↑(tensorHom (rightUnitor M).hom (𝟙 N)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)

tactic: change R at y
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
x : ↑M
y : ↑(of R R)
z : ↑N
⊢ ↑((associator M (of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
    ↑(tensorHom (rightUnitor M).hom (𝟙 N)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)

tactic: change x ⊗ₜ[R] ((leftUnitor N).hom) (y ⊗ₜ[R] z) = ((rightUnitor M).hom) (x ⊗ₜ[R] y) ⊗ₜ[R] z
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
x : ↑M
z : ↑N
y : R
⊢ ↑((associator M (of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
    ↑(tensorHom (rightUnitor M).hom (𝟙 N)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)

tactic: erw [TensorProduct.lid_tmul, TensorProduct.rid_tmul]
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
x : ↑M
z : ↑N
y : R
⊢ x ⊗ₜ[R] ↑(leftUnitor N).hom (y ⊗ₜ[R] z) = ↑(rightUnitor M).hom (x ⊗ₜ[R] y) ⊗ₜ[R] z

tactic: exact (TensorProduct.smul_tmul _ _ _).symm
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
x : ↑M
z : ↑N
y : R
⊢ x ⊗ₜ[R] (y • z) = (y • x) ⊗ₜ[R] z
Theorem: Submodule.le_comap_mkQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: simpa using (comap_mono bot_le : ker p.mkQ ≤ comap p.mkQ p')
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p'✝ : Submodule R M
R₂ : Type ?u.225550
M₂ : Type ?u.225553
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
p' : Submodule R (M ⧸ p)
⊢ p ≤ comap (mkQ p) p'
Theorem: abs_eq_neg_self
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: simp [abs_eq_max_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b c : α
⊢ abs a = -a ↔ a ≤ 0
Theorem: Lagrange.basis_eq_prod_sub_inv_mul_nodal_div
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [Lagrange.basis, basisDivisor, nodalWeight, prod_mul_distrib, map_prod, ←
  nodal_erase_eq_nodal_div hi, nodal]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hi : i ∈ s
⊢ Lagrange.basis s v i = ↑C (nodalWeight s v i) * (nodal s v / (X - ↑C (v i)))
Theorem: AdjoinRoot.Polynomial.quotQuotEquivComm_symm_mk_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp only [Polynomial.quotQuotEquivComm, quotientEquiv_symm_mk,
  polynomialQuotientEquivQuotientPolynomial_symm_mk]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f p : R[X]
⊢ ↑(RingEquiv.symm (quotQuotEquivComm I f))
      (↑(Ideal.Quotient.mk (span {↑(Ideal.Quotient.mk (Ideal.map C I)) f})) (↑(Ideal.Quotient.mk (Ideal.map C I)) p)) =
    ↑(Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)
Theorem: Polynomial.toLaurent_C_mul_X_pow
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: simp only [_root_.map_mul, Polynomial.toLaurent_C, Polynomial.toLaurent_X_pow]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
r : R
⊢ ↑toLaurent (↑Polynomial.C r * X ^ n) = ↑C r * T ↑n
Theorem: Complex.inv_zero
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [← ofReal_zero, ← ofReal_inv, inv_zero]
state_before: ⊢ 0⁻¹ = 0
Theorem: Ordinal.bsup_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [o.card.lift_id]
state_before: α : Type ?u.41767
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
c : Ordinal
ho : card o < cof c
⊢ Cardinal.lift (card o) < cof c
Theorem: Finset.hasSum_compl_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [add_comm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.430427
δ : Type ?u.430430
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
s : Finset β
⊢ HasSum f (∑ b in s, f b + a) ↔ HasSum f (a + ∑ i in s, f i)
Theorem: Finsupp.finsuppProdLEquiv_symm_apply
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: conv_rhs =>
  rw [← (finsuppProdLEquiv R).apply_symm_apply f, finsuppProdLEquiv_apply, Prod.mk.eta]
state_before: α✝ : Type ?u.645884
M✝ : Type ?u.645887
N : Type ?u.645890
P : Type ?u.645893
R✝ : Type ?u.645896
S : Type ?u.645899
inst✝¹⁰ : Semiring R✝
inst✝⁹ : Semiring S
inst✝⁸ : AddCommMonoid M✝
inst✝⁷ : Module R✝ M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ N
inst✝⁴ : AddCommMonoid P
inst✝³ : Module R✝ P
α : Type u_1
β : Type u_2
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : α →₀ β →₀ M
xy : α × β
⊢ ↑(↑(LinearEquiv.symm (finsuppProdLEquiv R)) f) xy = ↑(↑f xy.fst) xy.snd
Theorem: EuclideanGeometry.dist_center_inversion
File: Mathlib/Geometry/Euclidean/Inversion.lean

tactic: rw [dist_comm c, dist_comm c, dist_inversion_center]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R✝ : ℝ
c x : P
R : ℝ
⊢ dist c (inversion c R x) = R ^ 2 / dist c x
Theorem: ContinuousMap.cancel_left
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.36632
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f✝ g : C(α, β)
f : C(β, γ)
g₁ g₂ : C(α, β)
hf : Injective ↑f
h : comp f g₁ = comp f g₂
a : α
⊢ ↑f (↑g₁ a) = ↑f (↑g₂ a)
Theorem: MeasureTheory.Measure.join_zero
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.8097
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
⊢ join 0 = 0

tactic: simp only [hs, join_apply, lintegral_zero_measure, coe_zero, Pi.zero_apply]
state_before: case h
α : Type u_1
β : Type ?u.8097
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
⊢ ↑↑(join 0) s = ↑↑0 s
Theorem: Polynomial.derivative_X_add_C
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [derivative_add, derivative_X, derivative_C, add_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
c : R
⊢ ↑derivative (X + ↑C c) = 1
Theorem: Finite.surjective_of_injective
File: Mathlib/Data/Fintype/Card.lean

tactic: intro x
state_before: α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
⊢ Surjective f

tactic: have := Classical.propDecidable
state_before: α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
⊢ ∃ a, f a = x

tactic: cases nonempty_fintype α
state_before: α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
this : (a : Prop) → Decidable a
⊢ ∃ a, f a = x

tactic: have h₁ : image f univ = univ :=
  eq_of_subset_of_card_le (subset_univ _)
    ((card_image_of_injective univ hinj).symm ▸ le_rfl)
state_before: case intro
α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
this : (a : Prop) → Decidable a
val✝ : Fintype α
⊢ ∃ a, f a = x

tactic: have h₂ : x ∈ image f univ := h₁.symm ▸ mem_univ x
state_before: case intro
α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
this : (a : Prop) → Decidable a
val✝ : Fintype α
h₁ : image f univ = univ
⊢ ∃ a, f a = x

tactic: obtain ⟨y, h⟩ := mem_image.1 h₂
state_before: case intro
α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
this : (a : Prop) → Decidable a
val✝ : Fintype α
h₁ : image f univ = univ
h₂ : x ∈ image f univ
⊢ ∃ a, f a = x

tactic: exact ⟨y, h.2⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.26048
γ : Type ?u.26051
inst✝ : Finite α
f : α → α
hinj : Injective f
x : α
this : (a : Prop) → Decidable a
val✝ : Fintype α
h₁ : image f univ = univ
h₂ : x ∈ image f univ
y : α
h : y ∈ univ ∧ f y = x
⊢ ∃ a, f a = x
Theorem: Nat.not_mem_of_lt_sInf
File: Mathlib/Data/Nat/Lattice.lean

tactic: cases eq_empty_or_nonempty s with
| inl h => subst h; apply not_mem_empty
| inr h => rw [Nat.sInf_def h] at hm; exact Nat.find_min h hm
state_before: s : Set ℕ
m : ℕ
hm : m < sInf s
⊢ ¬m ∈ s

tactic: subst h
state_before: case inl
s : Set ℕ
m : ℕ
hm : m < sInf s
h : s = ∅
⊢ ¬m ∈ s

tactic: apply not_mem_empty
state_before: case inl
m : ℕ
hm : m < sInf ∅
⊢ ¬m ∈ ∅

tactic: rw [Nat.sInf_def h] at hm
state_before: case inr
s : Set ℕ
m : ℕ
hm : m < sInf s
h : Set.Nonempty s
⊢ ¬m ∈ s

tactic: exact Nat.find_min h hm
state_before: case inr
s : Set ℕ
m : ℕ
h : Set.Nonempty s
hm : m < Nat.find h
⊢ ¬m ∈ s
Theorem: Real.Angle.cos_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_zero, cos_coe, Real.cos_zero]
state_before: ⊢ cos 0 = 1
Theorem: LieSubalgebra.mem_normalizer_iff'
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: rw [Subtype.forall']
state_before: R : Type u_2
L : Type u_1
M : Type ?u.37972
M' : Type ?u.37975
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x : L
⊢ x ∈ normalizer H ↔ ∀ (y : L), y ∈ H → ⁅y, x⁆ ∈ H

tactic: rfl
state_before: R : Type u_2
L : Type u_1
M : Type ?u.37972
M' : Type ?u.37975
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x : L
⊢ x ∈ normalizer H ↔ ∀ (x_1 : { a // a ∈ H }), ⁅↑x_1, x⁆ ∈ H
Theorem: CategoryTheory.CostructuredArrow.projectQuotient_factors
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: dsimp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
⊢ S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫
      S.map (Iso.unop (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).unop.left.op)).inv ≫ P.unop.hom =
    A.hom

tactic: rw [← Category.assoc, ← S.map_comp, ← unop_comp]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
⊢ S.map (Subobject.arrow (Subobject.mk f.unop.left.op)).unop ≫
      S.map (Subobject.underlyingIso f.unop.left.op).inv.unop ≫ P.unop.hom =
    A.hom

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
⊢ S.map ((Subobject.underlyingIso f.unop.left.op).inv ≫ Subobject.arrow (Subobject.mk f.unop.left.op)).unop ≫
      P.unop.hom =
    A.hom
Theorem: InnerProductSpace.Core.norm_inner_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, norm_conj]
state_before: 𝕜 : Type u_1
E : Type ?u.580576
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ‖inner x y‖ = ‖inner y x‖
Theorem: discreteTopology_iff_nhds_ne
File: Mathlib/Topology/Order.lean

tactic: simp only [discreteTopology_iff_singleton_mem_nhds, nhdsWithin, inf_principal_eq_bot, compl_compl]
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s : Set α
inst✝ : TopologicalSpace α
⊢ DiscreteTopology α ↔ ∀ (x : α), 𝓝[{x}ᶜ] x = ⊥
Theorem: IsCoercive.bounded_below
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

tactic: rcases coercive with ⟨C, C_ge_0, coercivity⟩
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: refine' ⟨C, C_ge_0, _⟩
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
⊢ ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: intro v
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
⊢ ∀ (v : V), C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: by_cases h : 0 < ‖v‖
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
⊢ C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: refine' (mul_le_mul_right h).mp _
state_before: case pos
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
h : 0 < ‖v‖
⊢ C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: calc
  C * ‖v‖ * ‖v‖ ≤ B v v := coercivity v
  _ = ⟪B♯ v, v⟫_ℝ := (continuousLinearMapOfBilin_apply B v v).symm
  _ ≤ ‖B♯ v‖ * ‖v‖ := real_inner_le_norm (B♯ v) v
state_before: case pos
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
h : 0 < ‖v‖
⊢ C * ‖v‖ * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖ * ‖v‖

tactic: have : v = 0 := by simpa using h
state_before: case neg
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
h : ¬0 < ‖v‖
⊢ C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: simp [this]
state_before: case neg
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
h : ¬0 < ‖v‖
this : v = 0
⊢ C * ‖v‖ ≤ ‖↑(continuousLinearMapOfBilin B) v‖

tactic: simpa using h
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
C : ℝ
C_ge_0 : 0 < C
coercivity : ∀ (u : V), C * ‖u‖ * ‖u‖ ≤ ↑(↑B u) u
v : V
h : ¬0 < ‖v‖
⊢ v = 0
Theorem: TensorProduct.map₂_mk_top_top_eq_top
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: rw [← top_le_iff, ← span_tmul_eq_top, Submodule.map₂_eq_span_image2]
state_before: R : Type u_3
inst✝¹⁶ : CommSemiring R
R' : Type ?u.489165
inst✝¹⁵ : Monoid R'
R'' : Type ?u.489171
inst✝¹⁴ : Semiring R''
M : Type u_1
N : Type u_2
P : Type ?u.489183
Q : Type ?u.489186
S : Type ?u.489189
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
⊢ Submodule.map₂ (mk R M N) ⊤ ⊤ = ⊤

tactic: exact Submodule.span_mono fun _ ⟨m, n, h⟩ => ⟨m, n, trivial, trivial, h⟩
state_before: R : Type u_3
inst✝¹⁶ : CommSemiring R
R' : Type ?u.489165
inst✝¹⁵ : Monoid R'
R'' : Type ?u.489171
inst✝¹⁴ : Semiring R''
M : Type u_1
N : Type u_2
P : Type ?u.489183
Q : Type ?u.489186
S : Type ?u.489189
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Module R S
inst✝³ : DistribMulAction R' M
inst✝² : Module R'' M
inst✝¹ : SMulCommClass R R' M
inst✝ : SMulCommClass R R'' M
⊢ Submodule.span R {t | ∃ m n, m ⊗ₜ[R] n = t} ≤ Submodule.span R (Set.image2 (fun m n => ↑(↑(mk R M N) m) n) ↑⊤ ↑⊤)
Theorem: Int.natAbs_euclideanDomain_gcd
File: Mathlib/RingTheory/Int/Basic.lean

tactic: apply Nat.dvd_antisymm <;> rw [← Int.coe_nat_dvd]
state_before: a b : ℤ
⊢ natAbs (EuclideanDomain.gcd a b) = gcd a b

tactic: rw [Int.natAbs_dvd]
state_before: case a
a b : ℤ
⊢ ↑(natAbs (EuclideanDomain.gcd a b)) ∣ ↑(gcd a b)

tactic: exact Int.dvd_gcd (EuclideanDomain.gcd_dvd_left _ _) (EuclideanDomain.gcd_dvd_right _ _)
state_before: case a
a b : ℤ
⊢ EuclideanDomain.gcd a b ∣ ↑(gcd a b)

tactic: rw [Int.dvd_natAbs]
state_before: case a
a b : ℤ
⊢ ↑(gcd a b) ∣ ↑(natAbs (EuclideanDomain.gcd a b))

tactic: exact EuclideanDomain.dvd_gcd (Int.gcd_dvd_left _ _) (Int.gcd_dvd_right _ _)
state_before: case a
a b : ℤ
⊢ ↑(gcd a b) ∣ EuclideanDomain.gcd a b
Theorem: exists_open_nhds_one_mul_subset
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rcases exists_open_nhds_one_split hU with ⟨V, Vo, V1, hV⟩
state_before: ι : Type ?u.166179
α : Type ?u.166182
X : Type ?u.166185
M : Type u_1
N : Type ?u.166191
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
U : Set M
hU : U ∈ 𝓝 1
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ V * V ⊆ U

tactic: use V, Vo, V1
state_before: case intro.intro.intro
ι : Type ?u.166179
α : Type ?u.166182
X : Type ?u.166185
M : Type u_1
N : Type ?u.166191
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
U : Set M
hU : U ∈ 𝓝 1
V : Set M
Vo : IsOpen V
V1 : 1 ∈ V
hV : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ U
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ V * V ⊆ U

tactic: rintro _ ⟨x, y, hx, hy, rfl⟩
state_before: case intro.intro.intro
ι : Type ?u.166179
α : Type ?u.166182
X : Type ?u.166185
M : Type u_1
N : Type ?u.166191
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
U : Set M
hU : U ∈ 𝓝 1
V : Set M
Vo : IsOpen V
V1 : 1 ∈ V
hV : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ U
⊢ V * V ⊆ U

tactic: exact hV _ hx _ hy
state_before: case intro.intro.intro.intro.intro.intro.intro
ι : Type ?u.166179
α : Type ?u.166182
X : Type ?u.166185
M : Type u_1
N : Type ?u.166191
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
U : Set M
hU : U ∈ 𝓝 1
V : Set M
Vo : IsOpen V
V1 : 1 ∈ V
hV : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ U
x y : M
hx : x ∈ V
hy : y ∈ V
⊢ (fun x x_1 => x * x_1) x y ∈ U