1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.frequently_iff
File: Mathlib/Order/Filter/Basic.lean

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

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
P : α → Prop
⊢ (∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, q x ∧ P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x ∈ U, P x
state_after: no goals
Theorem: Mon_.Mon_tensor_mul_one
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: simp only [MonoidalCategory.whiskerLeft_comp_assoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ (M.X ⊗ N.X) ◁ (M.one ⊗ N.one) ≫ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom

tactic: slice_lhs 2 3 => rw [tensor_μ_natural_right]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ (M.X ⊗ N.X) ◁ (M.one ⊗ N.one) ≫ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ (tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ (M.X ◁ M.one ⊗ N.X ◁ N.one)) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom

tactic: slice_lhs 3 4 => rw [← tensor_comp, mul_one M, mul_one N]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ (tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ (M.X ◁ M.one ⊗ N.X ◁ N.one)) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom) =
    (ρ_ (M.X ⊗ N.X)).hom

tactic: symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom) =
    (ρ_ (M.X ⊗ N.X)).hom
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (ρ_ (M.X ⊗ N.X)).hom =
    (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom)

tactic: exact tensor_right_unitality C M.X N.X
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (ρ_ (M.X ⊗ N.X)).hom =
    (M.X ⊗ N.X) ◁ (λ_ (𝟙_ C)).inv ≫ tensor_μ C (M.X, N.X) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom)
state_after: no goals
Theorem: Set.toFinset_range
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : DecidableEq α
inst✝¹ : Fintype β
f : β → α
inst✝ : Fintype ↑(range f)
⊢ (range f).toFinset = Finset.image f Finset.univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : DecidableEq α
inst✝¹ : Fintype β
f : β → α
inst✝ : Fintype ↑(range f)
a✝ : α
⊢ a✝ ∈ (range f).toFinset ↔ a✝ ∈ Finset.image f Finset.univ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝² : DecidableEq α
inst✝¹ : Fintype β
f : β → α
inst✝ : Fintype ↑(range f)
a✝ : α
⊢ a✝ ∈ (range f).toFinset ↔ a✝ ∈ Finset.image f Finset.univ
state_after: no goals
Theorem: Cardinal.mk_toNat_of_infinite
File: Mathlib/SetTheory/Cardinal/ToNat.lean

tactic: simp
state_before: α : Type u
c d : Cardinal.{u}
h : Infinite α
⊢ toNat #α = 0
state_after: no goals
Theorem: Primrec.list_range
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Nat.rec [] (fun n_1 IH => (n, n_1, IH).2.2 ++ [(n, n_1, IH).2.1]) (id n) = List.range n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Nat.rec [] (fun n IH => IH ++ [n]) n = List.range n

tactic: induction n <;> simp [*, List.range_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Nat.rec [] (fun n IH => IH ++ [n]) n = List.range n
state_after: no goals
Theorem: ContextFreeGrammar.mem_reverse_language_iff_reverse_mem_language
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: refine ⟨reverse_mem_language_of_mem_reverse_language _, fun hw => ?_⟩
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
⊢ w ∈ g.reverse.language ↔ w.reverse ∈ g.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.language
⊢ w ∈ g.reverse.language

tactic: rw [← ContextFreeGrammar.reverse_involutive g] at hw
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.language
⊢ w ∈ g.reverse.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w ∈ g.reverse.language

tactic: rw [← List.reverse_reverse w]
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w ∈ g.reverse.language
state_after: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w.reverse.reverse ∈ g.reverse.language

tactic: exact g.reverse.reverse_mem_language_of_mem_reverse_language hw
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
hw : w.reverse ∈ g.reverse.reverse.language
⊢ w.reverse.reverse ∈ g.reverse.language
state_after: no goals
Theorem: AffineMap.homothety_neg_one_apply
File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

tactic: simp [homothety_apply, pointReflection_apply]
state_before: k : Type u_1
P₁ : Type u_2
P₂ : Type u_3
P₃ : Type u_4
P₄ : Type u_5
V₁ : Type u_6
V₂ : Type u_7
V₃ : Type u_8
V₄ : Type u_9
inst✝¹⁴ : Ring k
inst✝¹³ : AddCommGroup V₁
inst✝¹² : Module k V₁
inst✝¹¹ : AffineSpace V₁ P₁
inst✝¹⁰ : AddCommGroup V₂
inst✝⁹ : Module k V₂
inst✝⁸ : AffineSpace V₂ P₂
inst✝⁷ : AddCommGroup V₃
inst✝⁶ : Module k V₃
inst✝⁵ : AffineSpace V₃ P₃
inst✝⁴ : AddCommGroup V₄
inst✝³ : Module k V₄
inst✝² : AffineSpace V₄ P₄
R' : Type u_10
inst✝¹ : CommRing R'
inst✝ : Module R' V₁
c p : P₁
⊢ (homothety c (-1)) p = (pointReflection R' c) p
state_after: no goals
Theorem: Finset.image_biUnion
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [image_insert, biUnion_insert, ih]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝¹ : Finset α
t✝ : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq γ
f : α → β
s✝ : Finset α
t : β → Finset γ
this : DecidableEq α
a : α
s : Finset α
x✝ : a ∉ s
ih : (image f s).biUnion t = s.biUnion fun a => t (f a)
⊢ (image f (insert a s)).biUnion t = (insert a s).biUnion fun a => t (f a)
state_after: no goals
Theorem: PosSMulMono.lift
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: simp only [← hf, smul] at *
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulMono α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
hb : b₁ ≤ b₂
⊢ a • b₁ ≤ a • b₂
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
zero : f 0 = 0
inst✝ : PosSMulMono α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
hb : f b₁ ≤ f b₂
⊢ a • f b₁ ≤ a • f b₂

tactic: exact smul_le_smul_of_nonneg_left hb ha
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
zero : f 0 = 0
inst✝ : PosSMulMono α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
hb : f b₁ ≤ f b₂
⊢ a • f b₁ ≤ a • f b₂
state_after: no goals
Theorem: NonUnitalSubring.toSubring_toNonUnitalSubring
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

tactic: cases S
state_before: R : Type u_1
inst✝ : Ring R
S : NonUnitalSubring R
h1 : 1 ∈ S
⊢ (S.toSubring h1).toNonUnitalSubring = S
state_after: case mk
R : Type u_1
inst✝ : Ring R
toNonUnitalSubsemiring✝ : NonUnitalSubsemiring R
neg_mem'✝ : ∀ {x : R}, x ∈ toNonUnitalSubsemiring✝.carrier → -x ∈ toNonUnitalSubsemiring✝.carrier
h1 : 1 ∈ { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }
⊢ ({ toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }.toSubring h1).toNonUnitalSubring =
    { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }

tactic: rfl
state_before: case mk
R : Type u_1
inst✝ : Ring R
toNonUnitalSubsemiring✝ : NonUnitalSubsemiring R
neg_mem'✝ : ∀ {x : R}, x ∈ toNonUnitalSubsemiring✝.carrier → -x ∈ toNonUnitalSubsemiring✝.carrier
h1 : 1 ∈ { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }
⊢ ({ toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }.toSubring h1).toNonUnitalSubring =
    { toNonUnitalSubsemiring := toNonUnitalSubsemiring✝, neg_mem' := neg_mem'✝ }
state_after: no goals
Theorem: CategoryTheory.leftAdjointMate_comp
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp only [leftAdjointMate]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ (ᘁf) ≫ g = 𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (ᘁX ◁ ε_ (ᘁY) Y ≫ g ▷ 𝟙_ C) ⊗≫ 𝟙 Z
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ ((λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom) ≫ g =
    𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (ᘁX ◁ ε_ (ᘁY) Y ≫ g ▷ 𝟙_ C) ⊗≫ 𝟙 Z

tactic: coherence
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ ((λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom) ≫ g =
    𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (ᘁX ◁ ε_ (ᘁY) Y ≫ g ▷ 𝟙_ C) ⊗≫ 𝟙 Z
state_after: no goals

tactic: rw [whisker_exchange, tensorHom_def']
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ 𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (ᘁX ◁ ε_ (ᘁY) Y ≫ g ▷ 𝟙_ C) ⊗≫ 𝟙 Z =
    (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (g ⊗ f) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ 𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (g ▷ (Y ⊗ ᘁY) ≫ Z ◁ ε_ (ᘁY) Y) ⊗≫ 𝟙 Z =
    (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f ≫ g ▷ Y) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom

tactic: coherence
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ 𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (g ▷ (Y ⊗ ᘁY) ≫ Z ◁ ε_ (ᘁY) Y) ⊗≫ 𝟙 Z =
    (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f ≫ g ▷ Y) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom
state_after: no goals
Theorem: Complex.norm_one_add_mul_inv_le
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: rw [Set.mem_Icc] at ht
state_before: t : ℝ
ht : t ∈ Set.Icc 0 1
z : ℂ
hz : ‖z‖ < 1
⊢ ‖(1 + ↑t * z)⁻¹‖ ≤ (1 - ‖z‖)⁻¹
state_after: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ ‖(1 + ↑t * z)⁻¹‖ ≤ (1 - ‖z‖)⁻¹

tactic: rw [norm_inv, norm_eq_abs]
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ ‖(1 + ↑t * z)⁻¹‖ ≤ (1 - ‖z‖)⁻¹
state_after: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ (abs (1 + ↑t * z))⁻¹ ≤ (1 - ‖z‖)⁻¹

tactic: refine inv_le_inv_of_le (by linarith) ?_
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ (abs (1 + ↑t * z))⁻¹ ≤ (1 - ‖z‖)⁻¹
state_after: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖z‖ ≤ abs (1 + ↑t * z)

tactic: calc 1 - ‖z‖
  _ ≤ 1 - t * ‖z‖ := by
    nlinarith [norm_nonneg z]
  _ = 1 - ‖t * z‖ := by
    rw [norm_mul, norm_eq_abs (t :ℂ), abs_of_nonneg ht.1]
  _ ≤ ‖1 + t * z‖ := by
    rw [← norm_neg (t * z), ← sub_neg_eq_add]
    convert norm_sub_norm_le 1 (-(t * z))
    exact norm_one.symm
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖z‖ ≤ abs (1 + ↑t * z)
state_after: no goals

tactic: linarith
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 0 < 1 - ‖z‖
state_after: no goals

tactic: nlinarith [norm_nonneg z]
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖z‖ ≤ 1 - t * ‖z‖
state_after: no goals

tactic: rw [norm_mul, norm_eq_abs (t :ℂ), abs_of_nonneg ht.1]
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - t * ‖z‖ = 1 - ‖↑t * z‖
state_after: no goals

tactic: rw [← norm_neg (t * z), ← sub_neg_eq_add]
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖↑t * z‖ ≤ ‖1 + ↑t * z‖
state_after: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖-(↑t * z)‖ ≤ ‖1 - -(↑t * z)‖

tactic: convert norm_sub_norm_le 1 (-(t * z))
state_before: t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 - ‖-(↑t * z)‖ ≤ ‖1 - -(↑t * z)‖
state_after: case h.e'_3.h.e'_5
t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 = ‖1‖

tactic: exact norm_one.symm
state_before: case h.e'_3.h.e'_5
t : ℝ
ht : 0 ≤ t ∧ t ≤ 1
z : ℂ
hz : ‖z‖ < 1
⊢ 1 = ‖1‖
state_after: no goals
Theorem: List.dropSlice_zero₂
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

tactic: simp [dropSlice, dropSlice_zero₂]
state_before: α : Type u_1
n : Nat
x : α
xs : List α
⊢ dropSlice (n + 1) 0 (x :: xs) = x :: xs
state_after: no goals
Theorem: Set.preimage_div
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [image_div, image_preimage_eq_iff.2 hs, image_preimage_eq_iff.2 ht,
  image_preimage_eq_iff.2 (div_subset_range m hs ht)]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
s✝ t✝ : Set α
hm : Injective ⇑m
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
⊢ ⇑m '' (⇑m ⁻¹' (s / t)) = ⇑m '' (⇑m ⁻¹' s / ⇑m ⁻¹' t)
state_after: no goals
Theorem: Complex.cos_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, cos_add, sin_neg, cos_neg]
state_before: x y : ℂ
⊢ cos (x - y) = cos x * cos y + sin x * sin y
state_after: no goals
Theorem: Polynomial.splits_of_splits_of_dvd
File: Mathlib/Algebra/Polynomial/Splits.lean

tactic: obtain ⟨f, rfl⟩ := hgf
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf0 : f ≠ 0
hf : Splits i f
hgf : g ∣ f
⊢ Splits i g
state_after: case intro
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
g f : K[X]
hf0 : g * f ≠ 0
hf : Splits i (g * f)
⊢ Splits i g

tactic: exact (splits_of_splits_mul i hf0 hf).1
state_before: case intro
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
g f : K[X]
hf0 : g * f ≠ 0
hf : Splits i (g * f)
⊢ Splits i g
state_after: no goals
Theorem: Equiv.trans_toPartialEquiv
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp [PartialEquiv.trans_source, Equiv.toPartialEquiv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : α ≃ β
e' : β ≃ γ
⊢ (e.trans e').toPartialEquiv.source = (e.toPartialEquiv.trans e'.toPartialEquiv).source
state_after: no goals
Theorem: Set.ncard_eq_ncard_iff_ncard_diff_eq_ncard_diff
File: Mathlib/Data/Set/Card.lean

tactic: rw [← ncard_inter_add_ncard_diff_eq_ncard s t hs, ← ncard_inter_add_ncard_diff_eq_ncard t s ht,
  inter_comm, add_right_inj]
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
hs : autoParam s.Finite _auto✝
ht : autoParam t.Finite _auto✝
⊢ s.ncard = t.ncard ↔ (s \ t).ncard = (t \ s).ncard
state_after: no goals
Theorem: Fin.map_valEmbedding_Ici
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: clear b
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)
state_after: n : ℕ
a : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)

tactic: ext x
state_before: n : ℕ
a : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)
state_after: case a
n : ℕ
a : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ici a) ↔ x ∈ Icc (↑a) (n - 1)

tactic: simp only [exists_prop, Embedding.coe_subtype, mem_Ici, mem_map, mem_Icc]
state_before: case a
n : ℕ
a : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ici a) ↔ x ∈ Icc (↑a) (n - 1)
state_after: case a
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) ↔ ↑a ≤ x ∧ x ≤ n - 1

tactic: constructor
state_before: case a
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) ↔ ↑a ≤ x ∧ x ≤ n - 1
state_after: case a.mp
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) → ↑a ≤ x ∧ x ≤ n - 1

case a.mpr
n : ℕ
a : Fin n
x : ℕ
⊢ ↑a ≤ x ∧ x ≤ n - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x

tactic: cases n
state_before: case a.mpr
n : ℕ
a : Fin n
x : ℕ
⊢ ↑a ≤ x ∧ x ≤ n - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
state_after: case a.mpr.zero
x : ℕ
a : Fin 0
⊢ ↑a ≤ x ∧ x ≤ 0 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x

case a.mpr.succ
x n✝ : ℕ
a : Fin (n✝ + 1)
⊢ ↑a ≤ x ∧ x ≤ n✝ + 1 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x

tactic: rintro ⟨x, hx, rfl⟩
state_before: case a.mp
n : ℕ
a : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ valEmbedding a_1 = x) → ↑a ≤ x ∧ x ≤ n - 1
state_after: case a.mp.intro.intro
n : ℕ
a x : Fin n
hx : a ≤ x
⊢ ↑a ≤ valEmbedding x ∧ valEmbedding x ≤ n - 1

tactic: exact ⟨hx, Nat.le_sub_of_add_le <| x.2⟩
state_before: case a.mp.intro.intro
n : ℕ
a x : Fin n
hx : a ≤ x
⊢ ↑a ≤ valEmbedding x ∧ valEmbedding x ≤ n - 1
state_after: no goals

tactic: exact Fin.elim0 a
state_before: case a.mpr.zero
x : ℕ
a : Fin 0
⊢ ↑a ≤ x ∧ x ≤ 0 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
state_after: no goals

tactic: exact fun hx => ⟨⟨x, Nat.lt_succ_iff.2 hx.2⟩, hx.1, rfl⟩
state_before: case a.mpr.succ
x n✝ : ℕ
a : Fin (n✝ + 1)
⊢ ↑a ≤ x ∧ x ≤ n✝ + 1 - 1 → ∃ a_2, a ≤ a_2 ∧ valEmbedding a_2 = x
state_after: no goals
Theorem: Nat.choose_succ_self_right
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: rw [choose_succ_succ, choose_succ_self_right n, choose_self]
state_before: n : ℕ
⊢ (n + 1 + 1).choose (n + 1) = n + 1 + 1
state_after: no goals
Theorem: WithTop.coe_iSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iSup, iSup, WithTop.coe_sSup' h, ← range_comp, Function.comp_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : SupSet α
f : ι → α
h : BddAbove (range f)
⊢ ↑(⨆ i, f i) = ⨆ i, ↑(f i)
state_after: no goals
Theorem: ProbabilityTheory.kernel.lintegral_prod
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp_rw [prod, lintegral_compProd _ _ _ hg, swapLeft_apply, prodMkLeft_apply, Prod.swap_prod_mk]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel α γ)
inst✝ : IsSFiniteKernel η
a : α
g : β × γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : β × γ), g c ∂(κ ×ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), g (b, c) ∂η a ∂κ a
state_after: no goals
Theorem: toPrincipalIdeal_eq_iff
File: Mathlib/RingTheory/ClassGroup.lean

tactic: simp only [toPrincipalIdeal]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
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
I : (FractionalIdeal R⁰ K)ˣ
x : Kˣ
⊢ (toPrincipalIdeal R K) x = I ↔ spanSingleton R⁰ ↑x = ↑I
state_after: R : Type u_1
K : Type u_2
L : Type u_3
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
I : (FractionalIdeal R⁰ K)ˣ
x : Kˣ
⊢ { toFun := fun x => { val := spanSingleton R⁰ ↑x, inv := spanSingleton R⁰ (↑x)⁻¹, val_inv := ⋯, inv_val := ⋯ },
          map_one' := ⋯, map_mul' := ⋯ }
        x =
      I ↔
    spanSingleton R⁰ ↑x = ↑I

tactic: exact Units.ext_iff
state_before: R : Type u_1
K : Type u_2
L : Type u_3
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
I : (FractionalIdeal R⁰ K)ˣ
x : Kˣ
⊢ { toFun := fun x => { val := spanSingleton R⁰ ↑x, inv := spanSingleton R⁰ (↑x)⁻¹, val_inv := ⋯, inv_val := ⋯ },
          map_one' := ⋯, map_mul' := ⋯ }
        x =
      I ↔
    spanSingleton R⁰ ↑x = ↑I
state_after: no goals
Theorem: quasiIso_iff_comp_left
File: Mathlib/Algebra/Homology/QuasiIso.lean

tactic: simp only [quasiIso_iff, quasiIsoAt_iff_comp_left φ φ']
state_before: ι✝ : Type u_1
ι : Type u_2
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : L ⟶ M
inst✝² : ∀ (i : ι), K.HasHomology i
inst✝¹ : ∀ (i : ι), L.HasHomology i
inst✝ : ∀ (i : ι), M.HasHomology i
hφ : QuasiIso φ
⊢ QuasiIso (φ ≫ φ') ↔ QuasiIso φ'
state_after: no goals