tasksource/leandojo huggingface dataset:
Theorem: Nat.nextPowerOfTwo_dec
File: src/lean/Init/Data/Nat/Power2.lean

tactic: have : power * 2 = power + power := by simp_arith
state_before: n power : Nat
h₁ : power > 0
h₂ : power < n
⊢ n - power * 2 < n - power

tactic: rw [this, Nat.sub_add_eq]
state_before: n power : Nat
h₁ : power > 0
h₂ : power < n
this : power * 2 = power + power
⊢ n - power * 2 < n - power

tactic: exact Nat.sub_lt (Nat.zero_lt_sub_of_lt h₂) h₁
state_before: n power : Nat
h₁ : power > 0
h₂ : power < n
this : power * 2 = power + power
⊢ n - power - power < n - power

tactic: simp_arith
state_before: n power : Nat
h₁ : power > 0
h₂ : power < n
⊢ power * 2 = power + power
Theorem: MvPolynomial.expand_one
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: ext1 f
state_before: σ : Type u_1
τ : Type ?u.128090
R : Type u_2
S : Type ?u.128096
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
⊢ expand 1 = AlgHom.id R (MvPolynomial σ R)

tactic: rw [expand_one_apply, AlgHom.id_apply]
state_before: case hf
σ : Type u_1
τ : Type ?u.128090
R : Type u_2
S : Type ?u.128096
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ
⊢ ↑(expand 1) (X f) = ↑(AlgHom.id R (MvPolynomial σ R)) (X f)
Theorem: AlgebraicTopology.DoldKan.Γ₂N₂.natTrans_app_f_app
File: Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean

tactic: exact (N₂ ⋙ Γ₂).map P.decompId_i ≫
  (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans).app P.X ≫ P.decompId_p
state_before: C : Type ?u.84246
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
P : Karoubi (SimplicialObject C)
⊢ (N₂ ⋙ Γ₂).obj P ⟶ (𝟭 (Karoubi (SimplicialObject C))).obj P

tactic: dsimp only [natTrans]
state_before: C : Type u_1
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
P : Karoubi (SimplicialObject C)
⊢ natTrans.app P =
    (N₂ ⋙ Γ₂).map (Karoubi.decompId_i P) ≫ (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans).app P.X ≫ Karoubi.decompId_p P

tactic: rw [whiskeringLeft_obj_preimage_app
  (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans : _ ⟶ toKaroubi _ ⋙ 𝟭 _) P, Functor.id_map]
state_before: C : Type u_1
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
P : Karoubi (SimplicialObject C)
⊢ (((whiskeringLeft (SimplicialObject C) (Karoubi (SimplicialObject C)) (Karoubi (SimplicialObject C))).obj
              (toKaroubi (SimplicialObject C))).preimage
          (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans)).app
      P =
    (N₂ ⋙ Γ₂).map (Karoubi.decompId_i P) ≫ (compatibility_Γ₂N₁_Γ₂N₂.hom ≫ Γ₂N₁.natTrans).app P.X ≫ Karoubi.decompId_p P
Theorem: div_lt_one'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
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 d : α
⊢ a / b < 1 ↔ a < b
Theorem: ENNReal.toNNReal_eq_one_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp
state_before: α : Type ?u.23408
β : Type ?u.23411
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x = ↑1 ∨ x = ⊤ ∧ 1 = 0 ↔ x = 1
Theorem: Nat.range_of_succ
File: Mathlib/Data/Nat/Set.lean

tactic: rw [← image_singleton, range_comp, ← image_union, zero_union_range_succ, image_univ]
state_before: α : Type u_1
f : ℕ → α
⊢ {f 0} ∪ range (f ∘ succ) = range f
Theorem: Complex.neg_pi_lt_log_im
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp only [log_im, neg_pi_lt_arg]
state_before: x : ℂ
⊢ -π < (log x).im
Theorem: edist_eq_coe_nnnorm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [edist_eq_coe_nnnorm_div, div_one]
state_before: 𝓕 : Type ?u.329402
𝕜 : Type ?u.329405
α : Type ?u.329408
ι : Type ?u.329411
κ : Type ?u.329414
E : Type u_1
F : Type ?u.329420
G : Type ?u.329423
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x : E
⊢ edist x 1 = ↑‖x‖₊
Theorem: Set.iUnion_Ico_eq_Iio_self_iff
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
f : ι → α
a : α
⊢ (⋃ (i : ι), Ico (f i) a) = Iio a ↔ ∀ (x : α), x < a → ∃ i, f i ≤ x
Theorem: Option.join_ne_none
File: Std/Data/Option/Lemmas.lean

tactic: simp only [ne_none_iff_exists', join_eq_some, iff_self]
state_before: α✝ : Type u_1
x : Option (Option α✝)
⊢ join x ≠ none ↔ ∃ z, x = some (some z)
Theorem: AddMonoidAlgebra.Right.exists_add_of_mem_support_single_mul
File: Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean

tactic: rwa [support_mul_single _ _ (fun y => by rw [mul_one] : ∀ y : R, y * 1 = 0 ↔ _),
  Finset.mem_map] at hx
state_before: R : Type u_2
A : Type u_1
inst✝¹ : Semiring R
inst✝ : AddRightCancelSemigroup A
f : AddMonoidAlgebra R A
b x : A
hx : x ∈ (f * single b 1).support
⊢ ∃ a, a ∈ f.support ∧ a + b = x

tactic: rw [mul_one]
state_before: R : Type u_2
A : Type u_1
inst✝¹ : Semiring R
inst✝ : AddRightCancelSemigroup A
f : AddMonoidAlgebra R A
b x : A
hx : x ∈ (f * single b 1).support
y : R
⊢ y * 1 = 0 ↔ y = 0
Theorem: PseudoMetricSpace.replaceBornology_eq
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext
state_before: α✝ : Type u
β : Type v
X : Type ?u.169890
ι : Type ?u.169893
inst✝ : PseudoMetricSpace α✝
α : Type u_1
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
⊢ replaceBornology m H = m

tactic: rfl
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type ?u.169890
ι : Type ?u.169893
inst✝ : PseudoMetricSpace α✝
α : Type u_1
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
Theorem: MulHom.prod_unique
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply, Prod.mk.eta]
state_before: A : Type ?u.38398
B : Type ?u.38401
G : Type ?u.38404
H : Type ?u.38407
M : Type u_1
N : Type u_3
P : Type u_2
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
f : M →ₙ* N × P
x : M
⊢ ↑(MulHom.prod (comp (fst N P) f) (comp (snd N P) f)) x = ↑f x
Theorem: IsPGroup.to_sup_of_normal_right
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [← QuotientGroup.ker_mk' K, ← Subgroup.comap_map_eq]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p { x // x ∈ H }
hK : IsPGroup p { x // x ∈ K }
inst✝ : Subgroup.Normal K
⊢ IsPGroup p { x // x ∈ H ⊔ K }

tactic: apply (hH.map (QuotientGroup.mk' K)).comap_of_ker_isPGroup
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p { x // x ∈ H }
hK : IsPGroup p { x // x ∈ K }
inst✝ : Subgroup.Normal K
⊢ IsPGroup p { x // x ∈ Subgroup.comap (QuotientGroup.mk' K) (Subgroup.map (QuotientGroup.mk' K) H) }

tactic: rwa [QuotientGroup.ker_mk']
state_before: case hϕ
p : ℕ
G : Type u_1
inst✝¹ : Group G
H K : Subgroup G
hH : IsPGroup p { x // x ∈ H }
hK : IsPGroup p { x // x ∈ K }
inst✝ : Subgroup.Normal K
⊢ IsPGroup p { x // x ∈ MonoidHom.ker (QuotientGroup.mk' K) }
Theorem: Finmap.mem_list_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: induction' xs with x xs
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
⊢ a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs

tactic: cases' x with fst_i snd_i
state_before: case cons
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
x : Sigma β
xs : List (Sigma β)
tail_ih✝ : a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs
⊢ a ∈ List.toFinmap (x :: xs) ↔ ∃ b, { fst := a, snd := b } ∈ x :: xs

tactic: simp only [toFinmap_cons, *, exists_or, mem_cons, mem_insert, exists_and_left, Sigma.mk.inj_iff]
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a ∈ List.toFinmap ({ fst := fst_i, snd := snd_i } :: xs) ↔
    ∃ b, { fst := a, snd := b } ∈ { fst := fst_i, snd := snd_i } :: xs

tactic: refine (or_congr_left <| and_iff_left_of_imp ?_).symm
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs
fst_i : α
snd_i : β fst_i
⊢ (a = fst_i ∨ ∃ b, { fst := a, snd := b } ∈ xs) ↔ (a = fst_i ∧ ∃ x, HEq x snd_i) ∨ ∃ x, { fst := a, snd := x } ∈ xs

tactic: rintro rfl
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs
fst_i : α
snd_i : β fst_i
⊢ a = fst_i → ∃ x, HEq x snd_i

tactic: simp only [exists_eq, heq_iff_eq]
state_before: case cons.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
xs : List (Sigma β)
tail_ih✝ : a ∈ List.toFinmap xs ↔ ∃ b, { fst := a, snd := b } ∈ xs
snd_i : β a
⊢ ∃ x, HEq x snd_i

tactic: simp only [toFinmap_nil, not_mem_empty, find?, not_mem_nil, exists_false]
state_before: case nil
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
⊢ a ∈ List.toFinmap [] ↔ ∃ b, { fst := a, snd := b } ∈ []
Theorem: le_iff_exists_mul
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: rintro ⟨c, rfl⟩
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
⊢ (∃ c, b = a * c) → a ≤ b

tactic: exact le_self_mul
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedMonoid α
a c✝ d c : α
⊢ a ≤ a * c
Theorem: OrderIso.mulRight₀'_symm
File: Mathlib/Algebra/Order/WithZero.lean

tactic: ext
state_before: α : Type u_1
a✝ b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
a : α
ha : a ≠ 0
⊢ symm (mulRight₀' ha) = mulRight₀' (_ : a⁻¹ ≠ 0)

tactic: rfl
state_before: case h.h
α : Type u_1
a✝ b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
a : α
ha : a ≠ 0
x✝ : α
⊢ ↑(symm (mulRight₀' ha)) x✝ = ↑(mulRight₀' (_ : a⁻¹ ≠ 0)) x✝
Theorem: Down.compression_idem
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: ext s
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
⊢ 𝓓 a (𝓓 a 𝒜) = 𝓓 a 𝒜

tactic: refine' mem_compression.trans ⟨_, fun h => Or.inl ⟨h, erase_mem_compression_of_mem_compression h⟩⟩
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a (𝓓 a 𝒜) ↔ s ∈ 𝓓 a 𝒜

tactic: rintro (h | h)
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ 𝓓 a 𝒜 ∧ erase s a ∈ 𝓓 a 𝒜 ∨ ¬s ∈ 𝓓 a 𝒜 ∧ insert a s ∈ 𝓓 a 𝒜 → s ∈ 𝓓 a 𝒜

tactic: exact h.1
state_before: case a.inl
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
h : s ∈ 𝓓 a 𝒜 ∧ erase s a ∈ 𝓓 a 𝒜
⊢ s ∈ 𝓓 a 𝒜

tactic: cases h.1 (mem_compression_of_insert_mem_compression h.2)
state_before: case a.inr
α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ : Finset (Finset α)
s✝ : Finset α
a✝ a : α
𝒜 : Finset (Finset α)
s : Finset α
h : ¬s ∈ 𝓓 a 𝒜 ∧ insert a s ∈ 𝓓 a 𝒜
⊢ s ∈ 𝓓 a 𝒜
Theorem: Set.preimage_mul_const_Icc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic, h, inter_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => x * c) ⁻¹' Icc a b = Icc (b / c) (a / c)
Theorem: Nat.dvd_sub'
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: cases' le_total n m with H H
state_before: a b m✝ n✝ k✝ k m n : ℕ
h₁ : k ∣ m
h₂ : k ∣ n
⊢ k ∣ m - n

tactic: exact dvd_sub H h₁ h₂
state_before: case inl
a b m✝ n✝ k✝ k m n : ℕ
h₁ : k ∣ m
h₂ : k ∣ n
H : n ≤ m
⊢ k ∣ m - n

tactic: rw [tsub_eq_zero_iff_le.mpr H]
state_before: case inr
a b m✝ n✝ k✝ k m n : ℕ
h₁ : k ∣ m
h₂ : k ∣ n
H : m ≤ n
⊢ k ∣ m - n

tactic: exact dvd_zero k
state_before: case inr
a b m✝ n✝ k✝ k m n : ℕ
h₁ : k ∣ m
h₂ : k ∣ n
H : m ≤ n
⊢ k ∣ 0
Theorem: IsIntegral.mem_span_pow
File: Mathlib/RingTheory/PowerBasis.lean

tactic: obtain ⟨f, rfl⟩ := hy
state_before: R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x y : S
hx : IsIntegral R x
hy : ∃ f, y = ↑(aeval x) f
⊢ y ∈ Submodule.span R (Set.range fun i => x ^ ↑i)

tactic: apply mem_span_pow'.mpr _
state_before: case intro
R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x : S
hx : IsIntegral R x
f : R[X]
⊢ ↑(aeval x) f ∈ Submodule.span R (Set.range fun i => x ^ ↑i)

tactic: have := minpoly.monic hx
state_before: R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x : S
hx : IsIntegral R x
f : R[X]
⊢ ∃ f_1, degree f_1 < ↑(natDegree (minpoly R x)) ∧ ↑(aeval x) f = ↑(aeval x) f_1

tactic: refine' ⟨f %ₘ minpoly R x, (degree_modByMonic_lt _ this).trans_le degree_le_natDegree, _⟩
state_before: R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x : S
hx : IsIntegral R x
f : R[X]
this : Monic (minpoly R x)
⊢ ∃ f_1, degree f_1 < ↑(natDegree (minpoly R x)) ∧ ↑(aeval x) f = ↑(aeval x) f_1

tactic: conv_lhs => rw [← modByMonic_add_div f this]
state_before: R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x : S
hx : IsIntegral R x
f : R[X]
this : Monic (minpoly R x)
⊢ ↑(aeval x) f = ↑(aeval x) (f %ₘ minpoly R x)

tactic: simp only [add_zero, MulZeroClass.zero_mul, minpoly.aeval, aeval_add, AlgHom.map_mul]
state_before: R : Type u_1
S : Type u_2
T : Type ?u.680661
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.680964
B : Type ?u.680967
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type ?u.681389
inst✝¹ : Field K
inst✝ : Nontrivial R
x : S
hx : IsIntegral R x
f : R[X]
this : Monic (minpoly R x)
⊢ ↑(aeval x) (f %ₘ minpoly R x + minpoly R x * (f /ₘ minpoly R x)) = ↑(aeval x) (f %ₘ minpoly R x)
Theorem: Int.not_odd_iff
File: Mathlib/Data/Int/Parity.lean

tactic: rw [odd_iff, emod_two_ne_one]
state_before: m n : ℤ
⊢ ¬Odd n ↔ n % 2 = 0
Theorem: LinearIsometry.norm_toContinuousLinearMap
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simp
state_before: 𝕜 : Type u_2
𝕜₂ : Type u_3
𝕜₃ : Type ?u.3572227
E : Type u_1
Eₗ : Type ?u.3572233
F : Type u_4
Fₗ : Type ?u.3572239
G : Type ?u.3572242
Gₗ : Type ?u.3572245
𝓕 : Type ?u.3572248
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✝³ : NormedSpace 𝕜₃ G
inst✝² : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f✝ g : E →SL[σ₁₂] F
x y z : E
inst✝¹ : Nontrivial E
inst✝ : RingHomIsometric σ₁₂
f : E →ₛₗᵢ[σ₁₂] F
⊢ ∀ (x : E), ‖↑(toContinuousLinearMap f) x‖ = 1 * ‖x‖
Theorem: inf_iSup_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simpa only [inf_comm] using iSup_inf_eq f a
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.2775
inst✝ : Frame α
s t : Set α
a✝ b a : α
f : ι → α
⊢ (a ⊓ ⨆ (i : ι), f i) = ⨆ (i : ι), a ⊓ f i
Theorem: Rat.mkRat_self
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← normalize_eq_mkRat a.den_nz, normalize_self]
state_before: a : Rat
⊢ mkRat a.num a.den = a
Theorem: Num.pred_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [pred, PosNum.pred'_to_nat]
state_before: α : Type ?u.462274
p : PosNum
⊢ ↑(pred (pos p)) = Nat.pred ↑(pos p)

tactic: rfl
state_before: α : Type ?u.462274
p : PosNum
⊢ Nat.pred ↑p = Nat.pred ↑(pos p)
Theorem: Ideal.comap_isMaximal_of_surjective
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine' ⟨⟨comap_ne_top _ H.1.1, fun J hJ => _⟩⟩
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
⊢ IsMaximal (comap f K)

tactic: suffices map f J = ⊤ by
  have := congr_arg (comap f) this
  rw [comap_top, comap_map_of_surjective _ hf, eq_top_iff] at this
  rw [eq_top_iff]
  exact le_trans this (sup_le (le_of_eq rfl) (le_trans (comap_mono bot_le) (le_of_lt hJ)))
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
⊢ J = ⊤

tactic: refine'
  H.1.2 (map f J)
    (lt_of_le_of_ne (le_map_of_comap_le_of_surjective _ hf (le_of_lt hJ)) fun h =>
      ne_of_lt hJ (_root_.trans (congr_arg (comap f) h) _))
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
⊢ map f J = ⊤

tactic: rw [comap_map_of_surjective _ hf, sup_eq_left]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
h : K = map f J
⊢ comap f (map f J) = J

tactic: exact le_trans (comap_mono bot_le) (le_of_lt hJ)
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
h : K = map f J
⊢ comap f ⊥ ≤ J

tactic: have := congr_arg (comap f) this
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
this : map f J = ⊤
⊢ J = ⊤

tactic: rw [comap_top, comap_map_of_surjective _ hf, eq_top_iff] at this
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
this✝ : map f J = ⊤
this : comap f (map f J) = comap f ⊤
⊢ J = ⊤

tactic: rw [eq_top_iff]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
this✝ : map f J = ⊤
this : ⊤ ≤ J ⊔ comap f ⊥
⊢ J = ⊤

tactic: exact le_trans this (sup_le (le_of_eq rfl) (le_trans (comap_mono bot_le) (le_of_lt hJ)))
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f : F
I : Ideal R
hf : Function.Surjective ↑f
K : Ideal S
H : IsMaximal K
J : Ideal R
hJ : comap f K < J
this✝ : map f J = ⊤
this : ⊤ ≤ J ⊔ comap f ⊥
⊢ ⊤ ≤ J
Theorem: Filter.mem_coclosedCompact
File: Mathlib/Topology/SubsetProperties.lean

tactic: simp only [hasBasis_coclosedCompact.mem_iff, and_assoc]
state_before: α : Type u
β : Type v
ι : Type ?u.52091
π : ι → Type ?u.52096
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ s ∈ coclosedCompact α ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ tᶜ ⊆ s
Theorem: Real.arccos_le_pi_div_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, ← pi_div_four_le_arcsin]
state_before: x : ℝ
⊢ arccos x ≤ π / 4 ↔ sqrt 2 / 2 ≤ x

tactic: intro
state_before: case mpr
x : ℝ
⊢ π / 4 ≤ arcsin x → π / 2 - arcsin x ≤ π / 4

tactic: linarith
state_before: case mpr
x : ℝ
a✝ : π / 4 ≤ arcsin x
⊢ π / 2 - arcsin x ≤ π / 4
Theorem: lt_div_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, lt_div_iff hc]
state_before: ι : Type ?u.28580
α : Type u_1
β : Type ?u.28586
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 < c
⊢ a < b / c ↔ c * a < b
Theorem: Metric.thickening_cthickening_subset
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: obtain hε | hε := le_total ε 0
state_before: ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
⊢ thickening ε (cthickening δ s) ⊆ thickening (ε + δ) s

tactic: intro x
state_before: case inr
ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
hε : 0 ≤ ε
⊢ thickening ε (cthickening δ s) ⊆ thickening (ε + δ) s

tactic: simp_rw [mem_thickening_iff_exists_edist_lt, mem_cthickening_iff, ← infEdist_lt_iff,
  ENNReal.ofReal_add hε hδ]
state_before: case inr
ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x✝ : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
hε : 0 ≤ ε
x : α
⊢ x ∈ thickening ε (cthickening δ s) → x ∈ thickening (ε + δ) s

tactic: rintro ⟨y, hy, hxy⟩
state_before: case inr
ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x✝ : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
hε : 0 ≤ ε
x : α
⊢ (∃ z, infEdist z s ≤ ENNReal.ofReal δ ∧ edist x z < ENNReal.ofReal ε) →
    infEdist x s < ENNReal.ofReal ε + ENNReal.ofReal δ

tactic: exact infEdist_le_edist_add_infEdist.trans_lt
  (ENNReal.add_lt_add_of_lt_of_le (hy.trans_lt ENNReal.ofReal_lt_top).ne hxy hy)
state_before: case inr.intro.intro
ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x✝ : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
hε : 0 ≤ ε
x y : α
hy : infEdist y s ≤ ENNReal.ofReal δ
hxy : edist x y < ENNReal.ofReal ε
⊢ infEdist x s < ENNReal.ofReal ε + ENNReal.ofReal δ

tactic: simp only [thickening_of_nonpos hε, empty_subset]
state_before: case inl
ι : Sort ?u.155566
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s✝ t : Set α
x : α
ε : ℝ
hδ : 0 ≤ δ
s : Set α
hε : ε ≤ 0
⊢ thickening ε (cthickening δ s) ⊆ thickening (ε + δ) s