tasksource/leandojo huggingface dataset:
Theorem: ClassGroup.equiv_mk
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [ClassGroup.equiv, ClassGroup.mk, MonoidHom.comp_apply, QuotientGroup.congr_mk']
state_before: R : Type u_2
K : Type u_3
L : Type ?u.741973
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑(equiv K') (↑mk I) =
    ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K'))) (↑(Units.mapEquiv ↑(canonicalEquiv R⁰ K K')) I)

tactic: congr
state_before: R : Type u_2
K : Type u_3
L : Type ?u.741973
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K')))
      (↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K')))
        (↑(Units.map ↑(canonicalEquiv R⁰ K (FractionRing R))) I)) =
    ↑(QuotientGroup.mk' (MonoidHom.range (toPrincipalIdeal R K'))) (↑(Units.mapEquiv ↑(canonicalEquiv R⁰ K K')) I)

tactic: rw [← Units.eq_iff, Units.coe_mapEquiv, Units.coe_mapEquiv, Units.coe_map]
state_before: case h.e_6.h
R : Type u_2
K : Type u_3
L : Type ?u.741973
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K')))
      (↑(Units.map ↑(canonicalEquiv R⁰ K (FractionRing R))) I) =
    ↑(Units.mapEquiv ↑(canonicalEquiv R⁰ K K')) I

tactic: exact FractionalIdeal.canonicalEquiv_canonicalEquiv _ _ _ _ _
state_before: case h.e_6.h
R : Type u_2
K : Type u_3
L : Type ?u.741973
inst✝¹³ : CommRing R
inst✝¹² : Field K
inst✝¹¹ : Field L
inst✝¹⁰ : DecidableEq L
inst✝⁹ : Algebra R K
inst✝⁸ : IsFractionRing R K
inst✝⁷ : Algebra K L
inst✝⁶ : FiniteDimensional K L
inst✝⁵ : Algebra R L
inst✝⁴ : IsScalarTower R K L
inst✝³ : IsDomain R
K' : Type u_1
inst✝² : Field K'
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I : (FractionalIdeal R⁰ K)ˣ
⊢ ↑(RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K')) (↑↑(canonicalEquiv R⁰ K (FractionRing R)) ↑I) =
    ↑↑(canonicalEquiv R⁰ K K') ↑I
Theorem: Monoid.exponent_min
File: Mathlib/GroupTheory/Exponent.lean

tactic: by_contra' h
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
⊢ ∃ g, g ^ m ≠ 1

tactic: have hcon : exponent G ≤ m := exponent_min' m hpos h
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
⊢ False

tactic: linarith
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
hcon : exponent G ≤ m
⊢ False
Theorem: List.alternatingProd_cons
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [div_eq_mul_inv, alternatingProd_cons']
state_before: ι : Type ?u.167752
α : Type u_1
M : Type ?u.167758
N : Type ?u.167761
P : Type ?u.167764
M₀ : Type ?u.167767
G : Type ?u.167770
R : Type ?u.167773
inst✝ : CommGroup α
a : α
l : List α
⊢ alternatingProd (a :: l) = a / alternatingProd l
Theorem: IntermediateField.aeval_gen_minpoly
File: Mathlib/FieldTheory/Adjoin.lean

tactic: ext
state_before: F : Type u_2
inst✝⁴ : Field F
E : Type u_1
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.817326
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
⊢ ↑(aeval (AdjoinSimple.gen F α)) (minpoly F α) = 0

tactic: convert minpoly.aeval F α
state_before: case a
F : Type u_2
inst✝⁴ : Field F
E : Type u_1
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.817326
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
⊢ ↑(↑(aeval (AdjoinSimple.gen F α)) (minpoly F α)) = ↑0

tactic: conv in aeval α => rw [← AdjoinSimple.algebraMap_gen F α]
state_before: case h.e'_2
F : Type u_2
inst✝⁴ : Field F
E : Type u_1
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.817326
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
⊢ ↑(↑(aeval (AdjoinSimple.gen F α)) (minpoly F α)) = ↑(aeval α) (minpoly F α)

tactic: exact (aeval_algebraMap_apply E (AdjoinSimple.gen F α) _).symm
state_before: case h.e'_2
F : Type u_2
inst✝⁴ : Field F
E : Type u_1
inst✝³ : Field E
inst✝² : Algebra F E
α✝ : E
K : Type ?u.817326
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
⊢ ↑(↑(aeval (AdjoinSimple.gen F α)) (minpoly F α)) =
    ↑(aeval (↑(algebraMap { x // x ∈ F⟮α⟯ } E) (AdjoinSimple.gen F α))) (minpoly F α)
Theorem: CategoryTheory.Limits.Trident.app_zero
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: rw [← s.w (line j), parallelFamily_map_left]
state_before: J : Type w
C : Type u
inst✝ : Category C
X Y : C
f : J → (X ⟶ Y)
s : Trident f
j : J
⊢ s.π.app zero ≫ f j = s.π.app one
Theorem: Filter.iSup_principal
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_iSup, mem_principal, iUnion_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.116529
ι✝ : Sort x
f g : Filter α
s✝ t : Set α
ι : Sort w
s : ι → Set α
x : Set α
⊢ (x ∈ ⨆ (x : ι), 𝓟 (s x)) ↔ x ∈ 𝓟 (⋃ (i : ι), s i)
Theorem: Ordinal.le_add_left
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa only [zero_add] using add_le_add_right (Ordinal.zero_le b) a
state_before: α : Type ?u.162791
β : Type ?u.162794
γ : Type ?u.162797
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
⊢ a ≤ b + a
Theorem: Filter.tendsto_iInf
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, iff_self_iff, le_iInf_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.314967
ι : Sort x
f : α → β
x : Filter α
y : ι → Filter β
⊢ Tendsto f x (⨅ (i : ι), y i) ↔ ∀ (i : ι), Tendsto f x (y i)
Theorem: sdiff_sdiff_eq_sdiff_sup
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sdiff_right', inf_eq_right.2 h]
state_before: α : Type u
β : Type ?u.29623
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : z ≤ x
⊢ x \ (y \ z) = x \ y ⊔ z
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.inclusionOfMooreComplexMap
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

tactic: dsimp [AlgebraicTopology.inclusionOfMooreComplexMap, NormalizedMooreComplex.objX]
state_before: A : Type u_1
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ HomologicalComplex.Hom.f (AlgebraicTopology.inclusionOfMooreComplexMap X) (n + 1) ≫
      SimplicialObject.δ X (Fin.succ j) =
    0

tactic: rw [← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ j
  (by simp only [Finset.mem_univ])), assoc, kernelSubobject_arrow_comp, comp_zero]
state_before: A : Type u_1
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
      SimplicialObject.δ X (Fin.succ j) =
    0

tactic: simp only [Finset.mem_univ]
state_before: A : Type u_1
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ j ∈ Finset.univ
Theorem: Int.ceil_lt_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← lt_ceil, ← Int.cast_one, ceil_add_int]
state_before: F : Type ?u.216510
α : Type u_1
β : Type ?u.216516
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ↑⌈a⌉ < a + 1

tactic: apply lt_add_one
state_before: F : Type ?u.216510
α : Type u_1
β : Type ?u.216516
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a⌉ < ⌈a⌉ + 1
Theorem: Ordinal.CNF_sorted
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: refine' CNFRec b _ (fun o ho IH ↦ _) o
state_before: b o : Ordinal
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: simp only [CNF_zero]
state_before: case refine'_1
b o : Ordinal
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b 0))

tactic: cases' le_or_lt b 1 with hb hb
state_before: case refine'_2
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: simp only [CNF_of_le_one hb ho, map]
state_before: case refine'_2.inl
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : b ≤ 1
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: cases' lt_or_le o b with hob hbo
state_before: case refine'_2.inr
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: simp only [CNF_of_lt ho hob, map]
state_before: case refine'_2.inr.inl
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hob : o < b
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: rw [CNF_ne_zero ho, map_cons, sorted_cons]
state_before: case refine'_2.inr.inr
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hbo : b ≤ o
⊢ Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b o))

tactic: refine' ⟨fun a H ↦ _, IH⟩
state_before: case refine'_2.inr.inr
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hbo : b ≤ o
⊢ (∀ (b_1 : Ordinal), b_1 ∈ map Prod.fst (CNF b (o % b ^ log b o)) → (log b o, o / b ^ log b o).fst > b_1) ∧
    Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))

tactic: rw [mem_map] at H
state_before: case refine'_2.inr.inr
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hbo : b ≤ o
a : Ordinal
H : a ∈ map Prod.fst (CNF b (o % b ^ log b o))
⊢ (log b o, o / b ^ log b o).fst > a

tactic: rcases H with ⟨⟨a, a'⟩, H, rfl⟩
state_before: case refine'_2.inr.inr
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hbo : b ≤ o
a : Ordinal
H : ∃ a_1, a_1 ∈ CNF b (o % b ^ log b o) ∧ a_1.fst = a
⊢ (log b o, o / b ^ log b o).fst > a

tactic: exact (CNF_fst_le_log H).trans_lt (log_mod_opow_log_lt_log_self hb ho hbo)
state_before: case refine'_2.inr.inr.intro.mk.intro
b o✝ o : Ordinal
ho : o ≠ 0
IH : Sorted (fun x x_1 => x > x_1) (map Prod.fst (CNF b (o % b ^ log b o)))
hb : 1 < b
hbo : b ≤ o
a a' : Ordinal
H : (a, a') ∈ CNF b (o % b ^ log b o)
⊢ (log b o, o / b ^ log b o).fst > (a, a').fst
Theorem: Asymptotics.IsBigO.eq_zero_of_norm_pow_within
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp_rw [sub_self, norm_zero, zero_pow hn]
state_before: α : Type ?u.653911
β : Type ?u.653914
E : Type ?u.653917
F : Type ?u.653920
G : Type ?u.653923
E' : Type ?u.653926
F' : Type ?u.653929
G' : Type ?u.653932
E'' : Type u_1
F'' : Type u_2
G'' : Type ?u.653941
R : Type ?u.653944
R' : Type ?u.653947
𝕜 : Type ?u.653950
𝕜' : Type ?u.653953
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : E'' → F''
s : Set E''
x₀ : E''
n : ℕ
h : f =O[𝓝[s] x₀] fun x => ‖x - x₀‖ ^ n
hx₀ : x₀ ∈ s
hn : 0 < n
⊢ ‖x₀ - x₀‖ ^ n = 0
Theorem: Stream'.Seq.map_tail
File: Mathlib/Data/Seq/Seq.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : IsSeq s
⊢ map f (tail { val := s, property := al }) = tail (map f { val := s, property := al })

tactic: dsimp [tail, map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
s : Stream' (Option α)
al : IsSeq s
⊢ ↑(map f (tail { val := s, property := al })) = ↑(tail (map f { val := s, property := al }))
Theorem: Multiset.fold_hom
File: Mathlib/Data/Multiset/Fold.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
op' : β → β → β
inst✝¹ : IsCommutative β op'
inst✝ : IsAssociative β op'
m : α → β
hm : ∀ (x y : α), m (op x y) = op' (m x) (m y)
b : α
s : Multiset α
⊢ fold op' (m b) (map m 0) = m (fold op b 0)

tactic: simp (config := { contextual := true }) [hm]
state_before: α : Type u_2
β : Type u_1
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
op' : β → β → β
inst✝¹ : IsCommutative β op'
inst✝ : IsAssociative β op'
m : α → β
hm : ∀ (x y : α), m (op x y) = op' (m x) (m y)
b : α
s : Multiset α
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    fold op' (m b) (map m s) = m (fold op b s) → fold op' (m b) (map m (a ::ₘ s)) = m (fold op b (a ::ₘ s))
Theorem: Function.Injective.lieAlgebra_isSolvable
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: obtain ⟨k, hk⟩ := id h₁
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ↑f
⊢ IsSolvable R L'

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ↑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ IsSolvable R L'

tactic: apply LieIdeal.bot_of_map_eq_bot h₂
state_before: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ↑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ derivedSeries R L' k = ⊥

tactic: rw [eq_bot_iff, ← hk]
state_before: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ↑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) = ⊥

tactic: apply LieIdeal.derivedSeries_map_le
state_before: case mk.intro
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
h₁ : IsSolvable R L
h₂ : Injective ↑f
k : ℕ
hk : derivedSeries R L k = ⊥
⊢ LieIdeal.map f (derivedSeries R L' k) ≤ derivedSeries R L k
Theorem: Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: nth_rw 1 [← coe_toReal θ]
state_before: θ : Angle
⊢ 0 ≤ cos θ ↔ abs (toReal θ) ≤ π / 2

tactic: rw [abs_le, cos_coe]
state_before: θ : Angle
⊢ 0 ≤ cos ↑(toReal θ) ↔ abs (toReal θ) ≤ π / 2

tactic: refine' ⟨fun h => _, cos_nonneg_of_mem_Icc⟩
state_before: θ : Angle
⊢ 0 ≤ Real.cos (toReal θ) ↔ -(π / 2) ≤ toReal θ ∧ toReal θ ≤ π / 2

tactic: by_contra hn
state_before: θ : Angle
h : 0 ≤ Real.cos (toReal θ)
⊢ -(π / 2) ≤ toReal θ ∧ toReal θ ≤ π / 2

tactic: rw [not_and_or, not_le, not_le] at hn
state_before: θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : ¬(-(π / 2) ≤ toReal θ ∧ toReal θ ≤ π / 2)
⊢ False

tactic: refine' (not_lt.2 h) _
state_before: θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2) ∨ π / 2 < toReal θ
⊢ False

tactic: rcases hn with (hn | hn)
state_before: θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2) ∨ π / 2 < toReal θ
⊢ Real.cos (toReal θ) < 0

tactic: rw [← Real.cos_neg]
state_before: case inl
θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2)
⊢ Real.cos (toReal θ) < 0

tactic: refine' cos_neg_of_pi_div_two_lt_of_lt (by linarith) _
state_before: case inl
θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2)
⊢ Real.cos (-toReal θ) < 0

tactic: linarith [neg_pi_lt_toReal θ]
state_before: case inl
θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2)
⊢ -toReal θ < π + π / 2

tactic: linarith
state_before: θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : toReal θ < -(π / 2)
⊢ π / 2 < -toReal θ

tactic: refine' cos_neg_of_pi_div_two_lt_of_lt hn _
state_before: case inr
θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : π / 2 < toReal θ
⊢ Real.cos (toReal θ) < 0

tactic: linarith [toReal_le_pi θ]
state_before: case inr
θ : Angle
h : 0 ≤ Real.cos (toReal θ)
hn : π / 2 < toReal θ
⊢ toReal θ < π + π / 2
Theorem: Rat.den_div_eq_of_coprime
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [←Int.natAbs_of_nonneg hb0.le, ← Rat.divInt_eq_div,
  ←mk_eq_divInt _ _ (Int.natAbs_ne_zero.mpr hb0.ne') h]
state_before: a b : ℤ
hb0 : 0 < b
h : Nat.coprime (Int.natAbs a) (Int.natAbs b)
⊢ ↑(↑a / ↑b).den = b
Theorem: MeasureTheory.Measure.LebesgueDecomposition.iSup_mem_measurableLE'
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: convert iSup_mem_measurableLE f hf n
state_before: α : Type u_1
β : Type ?u.112015
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), f n ∈ measurableLE μ ν
n : ℕ
⊢ (⨆ (k : ℕ) (_ : k ≤ n), f k) ∈ measurableLE μ ν

tactic: refine Option.ext fun x => ?_
state_before: case h.e'_4.h
α : Type u_1
β : Type ?u.112015
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), f n ∈ measurableLE μ ν
n : ℕ
x✝ : α
⊢ iSup (fun k => ⨆ (_ : k ≤ n), f k) x✝ = ⨆ (k : ℕ) (_ : k ≤ n), f k x✝

tactic: simp
state_before: case h.e'_4.h
α : Type u_1
β : Type ?u.112015
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
hf : ∀ (n : ℕ), f n ∈ measurableLE μ ν
n : ℕ
x✝ : α
x : ℝ≥0
⊢ x ∈ iSup (fun k => ⨆ (_ : k ≤ n), f k) x✝ ↔ x ∈ ⨆ (k : ℕ) (_ : k ≤ n), f k x✝
Theorem: MeasurableEquiv.measurableSet_image
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rw [image_eq_preimage, measurableSet_preimage]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.796326
δ : Type ?u.796329
δ' : Type ?u.796332
ι : Sort uι
s✝ t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set α
⊢ MeasurableSet (↑e '' s) ↔ MeasurableSet s
Theorem: map_rootsOfUnity
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rintro _ ⟨ζ, h, rfl⟩
state_before: M : Type u_1
N : Type u_2
G : Type ?u.365670
R : Type ?u.365673
S : Type ?u.365676
F : Type ?u.365679
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l : ℕ+
f : Mˣ →* Nˣ
k : ℕ+
⊢ Subgroup.map f (rootsOfUnity k M) ≤ rootsOfUnity k N

tactic: simp_all only [← map_pow, mem_rootsOfUnity, SetLike.mem_coe, MonoidHom.map_one]
state_before: case intro.intro
M : Type u_1
N : Type u_2
G : Type ?u.365670
R : Type ?u.365673
S : Type ?u.365676
F : Type ?u.365679
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l : ℕ+
f : Mˣ →* Nˣ
k : ℕ+
ζ : Mˣ
h : ζ ∈ ↑(rootsOfUnity k M)
⊢ ↑f ζ ∈ rootsOfUnity k N
Theorem: LinearMap.rTensor_neg
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: simp only [← coe_rTensorHom]
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_4
N : Type u_2
P : Type u_3
Q : Type ?u.1468032
S : Type ?u.1468035
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f : N →ₗ[R] P
⊢ rTensor M (-f) = -rTensor M f

tactic: exact (rTensorHom (R:=R) (N:=N) (P:=P) M).map_neg f
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_4
N : Type u_2
P : Type u_3
Q : Type ?u.1468032
S : Type ?u.1468035
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f : N →ₗ[R] P
⊢ ↑(rTensorHom M) (-f) = -↑(rTensorHom M) f
Theorem: Cardinal.lift_iSup
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [iSup, iSup, lift_sSup hf, ← range_comp]
state_before: α β : Type u
ι : Type v
f : ι → Cardinal
hf : BddAbove (range f)
⊢ lift (iSup f) = ⨆ (i : ι), lift (f i)

tactic: simp [Function.comp]
state_before: α β : Type u
ι : Type v
f : ι → Cardinal
hf : BddAbove (range f)
⊢ sSup (range (lift ∘ f)) = sSup (range fun i => lift (f i))
Theorem: Ideal.iInf_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [← Finset.inf_univ_eq_iInf, finset_inf_span_singleton]
state_before: R : Type u
ι✝ : Type ?u.255689
inst✝¹ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_1
inst✝ : Fintype ι
I : ι → R
hI : ∀ (i j : ι), i ≠ j → IsCoprime (I i) (I j)
⊢ (⨅ (i : ι), span {I i}) = span {∏ i : ι, I i}

tactic: rwa [Finset.coe_univ, Set.pairwise_univ]
state_before: case hI
R : Type u
ι✝ : Type ?u.255689
inst✝¹ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_1
inst✝ : Fintype ι
I : ι → R
hI : ∀ (i j : ι), i ≠ j → IsCoprime (I i) (I j)
⊢ Set.Pairwise (↑Finset.univ) (IsCoprime on fun i => I i)
Theorem: ContinuousLinearEquiv.one_le_norm_mul_norm_symm
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rw [mul_comm]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.3787210
E : Type u_3
Eₗ : Type ?u.3787216
F : Type u_4
Fₗ : Type ?u.3787222
G : Type ?u.3787225
Gₗ : Type ?u.3787228
𝓕 : Type ?u.3787231
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝⁴ : RingHomInvPair σ₁₂ σ₂₁
inst✝³ : RingHomInvPair σ₂₁ σ₁₂
inst✝² : RingHomIsometric σ₂₁
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : Nontrivial E
e : E ≃SL[σ₁₂] F
⊢ 1 ≤ ‖↑e‖ * ‖↑(ContinuousLinearEquiv.symm e)‖

tactic: convert(e.symm : F →SL[σ₂₁] E).op_norm_comp_le (e : E →SL[σ₁₂] F)
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.3787210
E : Type u_3
Eₗ : Type ?u.3787216
F : Type u_4
Fₗ : Type ?u.3787222
G : Type ?u.3787225
Gₗ : Type ?u.3787228
𝓕 : Type ?u.3787231
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝⁴ : RingHomInvPair σ₁₂ σ₂₁
inst✝³ : RingHomInvPair σ₂₁ σ₁₂
inst✝² : RingHomIsometric σ₂₁
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : Nontrivial E
e : E ≃SL[σ₁₂] F
⊢ 1 ≤ ‖↑(ContinuousLinearEquiv.symm e)‖ * ‖↑e‖

tactic: rw [e.coe_symm_comp_coe, ContinuousLinearMap.norm_id]
state_before: case h.e'_3
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.3787210
E : Type u_3
Eₗ : Type ?u.3787216
F : Type u_4
Fₗ : Type ?u.3787222
G : Type ?u.3787225
Gₗ : Type ?u.3787228
𝓕 : Type ?u.3787231
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₁ : 𝕜₂ →+* 𝕜
inst✝⁴ : RingHomInvPair σ₁₂ σ₂₁
inst✝³ : RingHomInvPair σ₂₁ σ₁₂
inst✝² : RingHomIsometric σ₂₁
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : Nontrivial E
e : E ≃SL[σ₁₂] F
⊢ 1 = ‖comp ↑(ContinuousLinearEquiv.symm e) ↑e‖