1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: GeneralizedContinuedFraction.get?_of_eq_some_of_succ_get?_intFractPair_stream
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: unfold of IntFractPair.seq1
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp_succ_n : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
⊢ (of v).s.get? n = some { a := 1, b := ↑ifp_succ_n.b }
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp_succ_n : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
⊢ (match (IntFractPair.of v, Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
          | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).s.get?
      n =
    some { a := 1, b := ↑ifp_succ_n.b }

tactic: simp [Stream'.Seq.map_tail, Stream'.Seq.get?_tail, Stream'.Seq.map_get?, stream_succ_nth_eq]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
ifp_succ_n : IntFractPair K
stream_succ_nth_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n
⊢ (match (IntFractPair.of v, Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
          | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).s.get?
      n =
    some { a := 1, b := ↑ifp_succ_n.b }
state_after: no goals
Theorem: NumberField.canonicalEmbedding.norm_le_iff
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

tactic: obtain hr | hr := lt_or_le r 0
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r
state_after: case inl
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

case inr
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : 0 ≤ r
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

tactic: obtain ⟨φ⟩ := (inferInstance : Nonempty (K →+* ℂ))
state_before: case inl
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r
state_after: case inl.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

tactic: refine iff_of_false ?_ ?_
state_before: case inl.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r
state_after: case inl.intro.refine_1
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ¬‖(canonicalEmbedding K) x‖ ≤ r

case inl.intro.refine_2
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ¬∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

tactic: exact (hr.trans_le (norm_nonneg _)).not_le
state_before: case inl.intro.refine_1
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ¬‖(canonicalEmbedding K) x‖ ≤ r
state_after: no goals

tactic: exact fun h => hr.not_le (le_trans (norm_nonneg _) (h φ))
state_before: case inl.intro.refine_2
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : r < 0
φ : K →+* ℂ
⊢ ¬∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r
state_after: no goals

tactic: lift r to NNReal using hr
state_before: case inr
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : ℝ
hr : 0 ≤ r
⊢ ‖(canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r
state_after: case inr.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : NNReal
⊢ ‖(canonicalEmbedding K) x‖ ≤ ↑r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ ↑r

tactic: simp_rw [← coe_nnnorm, nnnorm_eq, NNReal.coe_le_coe, Finset.sup_le_iff, Finset.mem_univ,
  forall_true_left]
state_before: case inr.intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : K
r : NNReal
⊢ ‖(canonicalEmbedding K) x‖ ≤ ↑r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ ↑r
state_after: no goals
Theorem: Set.not_mem_iff_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: unfold boolIndicator
state_before: α : Type u_1
s : Set α
x : α
⊢ x ∉ s ↔ s.boolIndicator x = false
state_after: α : Type u_1
s : Set α
x : α
⊢ x ∉ s ↔ (if x ∈ s then true else false) = false

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
s : Set α
x : α
⊢ x ∉ s ↔ (if x ∈ s then true else false) = false
state_after: no goals
Theorem: WriterT.goto_mkLabel'
File: Mathlib/Control/Monad/Cont.lean

tactic: cases x
state_before: m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : Monoid ω
x : Label (α × ω) m β
i : α
⊢ goto (mkLabel' x) i = monadLift (goto x (i, 1))
state_after: case mk
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : Monoid ω
i : α
apply✝ : α × ω → m β
⊢ goto (mkLabel' { apply := apply✝ }) i = monadLift (goto { apply := apply✝ } (i, 1))

tactic: rfl
state_before: case mk
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : Monoid ω
i : α
apply✝ : α × ω → m β
⊢ goto (mkLabel' { apply := apply✝ }) i = monadLift (goto { apply := apply✝ } (i, 1))
state_after: no goals
Theorem: Set.countable_infinite_iff_nonempty_denumerable
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [nonempty_denumerable_iff, ← Set.infinite_coe_iff, countable_coe_iff]
state_before: α✝ β : Type u
α : Type u_1
s : Set α
⊢ s.Countable ∧ s.Infinite ↔ Nonempty (Denumerable ↑s)
state_after: no goals
Theorem: ArithmeticFunction.cardFactors_eq_one_iff_prime
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: refine ⟨fun h => ?_, fun h => List.length_eq_one.2 ⟨n, factors_prime h⟩⟩
state_before: R : Type u_1
n : ℕ
⊢ Ω n = 1 ↔ Nat.Prime n
state_after: R : Type u_1
n : ℕ
h : Ω n = 1
⊢ Nat.Prime n

tactic: cases' n with n
state_before: R : Type u_1
n : ℕ
h : Ω n = 1
⊢ Nat.Prime n
state_after: case zero
R : Type u_1
h : Ω 0 = 1
⊢ Nat.Prime 0

case succ
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
⊢ Nat.Prime (n + 1)

tactic: rcases List.length_eq_one.1 h with ⟨x, hx⟩
state_before: case succ
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
⊢ Nat.Prime (n + 1)
state_after: case succ.intro
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ Nat.Prime (n + 1)

tactic: rw [← prod_factors n.add_one_ne_zero, hx, List.prod_singleton]
state_before: case succ.intro
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ Nat.Prime (n + 1)
state_after: case succ.intro
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ Nat.Prime x

tactic: apply prime_of_mem_factors
state_before: case succ.intro
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ Nat.Prime x
state_after: case succ.intro.h
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ x ∈ ?succ.intro.n.factors

case succ.intro.n
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ ℕ

tactic: rw [hx, List.mem_singleton]
state_before: case succ.intro.h
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ x ∈ ?succ.intro.n.factors

case succ.intro.n
R : Type u_1
n : ℕ
h : Ω (n + 1) = 1
x : ℕ
hx : (n + 1).factors = [x]
⊢ ℕ
state_after: no goals

tactic: simp at h
state_before: case zero
R : Type u_1
h : Ω 0 = 1
⊢ Nat.Prime 0
state_after: no goals
Theorem: Complex.isCauSeq_im
File: Mathlib/Data/Complex/Abs.lean

tactic: simpa only [← ofReal_sub, abs_ofReal, sub_re] using (abs_im_le_abs _).trans_lt $ H _ ij
state_before: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
H : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
ij : j ≥ i
⊢ |(fun n => (↑f n).im) j - (fun n => (↑f n).im) i| < ε
state_after: no goals
Theorem: UniformConvexOn.mono
File: Mathlib/Analysis/Convex/Strong.lean

tactic: gcongr
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y - a * b * φ ‖x - y‖ ≤ a • f x + b • f y - a * b * ψ ‖x - y‖
state_after: case h.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖

tactic: apply hψφ
state_before: case h.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖
state_after: no goals
Theorem: add_thirds
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_add_div_same, div_add_div_same, ← two_mul, ← add_one_mul 2 a, two_add_one_eq_three,
  mul_div_cancel_left₀ a three_ne_zero]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
⊢ a / 3 + a / 3 + a / 3 = a
state_after: no goals
Theorem: isQuasiregular_iff
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : NonUnitalSemiring R
x : R
⊢ IsQuasiregular x ↔ ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
state_after: case mp
R : Type u_1
inst✝ : NonUnitalSemiring R
x : R
⊢ IsQuasiregular x → ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0

case mpr
R : Type u_1
inst✝ : NonUnitalSemiring R
x : R
⊢ (∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0) → IsQuasiregular x

tactic: rintro ⟨u, rfl⟩
state_before: case mp
R : Type u_1
inst✝ : NonUnitalSemiring R
x : R
⊢ IsQuasiregular x → ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
state_after: case mp.intro
R : Type u_1
inst✝ : NonUnitalSemiring R
u : (PreQuasiregular R)ˣ
⊢ ∃ y, y + equiv.symm ↑u + equiv.symm ↑u * y = 0 ∧ equiv.symm ↑u + y + y * equiv.symm ↑u = 0

tactic: exact ⟨equiv.symm u⁻¹.val, by simp⟩
state_before: case mp.intro
R : Type u_1
inst✝ : NonUnitalSemiring R
u : (PreQuasiregular R)ˣ
⊢ ∃ y, y + equiv.symm ↑u + equiv.symm ↑u * y = 0 ∧ equiv.symm ↑u + y + y * equiv.symm ↑u = 0
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝ : NonUnitalSemiring R
u : (PreQuasiregular R)ˣ
⊢ equiv.symm ↑u⁻¹ + equiv.symm ↑u + equiv.symm ↑u * equiv.symm ↑u⁻¹ = 0 ∧
    equiv.symm ↑u + equiv.symm ↑u⁻¹ + equiv.symm ↑u⁻¹ * equiv.symm ↑u = 0
state_after: no goals

tactic: rintro ⟨y, hy₁, hy₂⟩
state_before: case mpr
R : Type u_1
inst✝ : NonUnitalSemiring R
x : R
⊢ (∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0) → IsQuasiregular x
state_after: case mpr.intro.intro
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ IsQuasiregular x

tactic: refine ⟨⟨equiv x, equiv y, ?_, ?_⟩, rfl⟩
state_before: case mpr.intro.intro
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ IsQuasiregular x
state_after: case mpr.intro.intro.refine_1
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv x * equiv y = 1

case mpr.intro.intro.refine_2
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv y * equiv x = 1

tactic: all_goals
  apply equiv.symm.injective
  assumption
state_before: case mpr.intro.intro.refine_1
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv x * equiv y = 1

case mpr.intro.intro.refine_2
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv y * equiv x = 1
state_after: no goals

tactic: apply equiv.symm.injective
state_before: case mpr.intro.intro.refine_2
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv y * equiv x = 1
state_after: case mpr.intro.intro.refine_2.a
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv.symm (equiv y * equiv x) = equiv.symm 1

tactic: assumption
state_before: case mpr.intro.intro.refine_2.a
R : Type u_1
inst✝ : NonUnitalSemiring R
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ equiv.symm (equiv y * equiv x) = equiv.symm 1
state_after: no goals
Theorem: LieSubalgebra.mem_inf
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [← mem_coe_submodule, ← mem_coe_submodule, ← mem_coe_submodule, inf_coe_to_submodule,
  Submodule.mem_inf]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
x : L
⊢ x ∈ K ⊓ K' ↔ x ∈ K ∧ x ∈ K'
state_after: no goals
Theorem: Batteries.RBNode.setBlack_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: cases t <;> simp [setBlack]
state_before: α : Type u_1
t : RBNode α
⊢ t.setBlack.toList = t.toList
state_after: no goals
Theorem: Finset.Colex.le_iff_sdiff_subset_lowerClosure
File: Mathlib/Combinatorics/Colex.lean

tactic: simp [le_def, Set.subset_def, and_assoc]
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s✝ t✝ u : Finset α
a b : α
inst✝ : DecidableEq α
s t : Colex α
⊢ s ≤ t ↔ ↑s.ofColex \ ↑t.ofColex ⊆ ↑(lowerClosure (↑t.ofColex \ ↑s.ofColex))
state_after: no goals
Theorem: Asymptotics.isEquivalent_of_tendsto_one
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rw [isEquivalent_iff_exists_eq_mul]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x = 0 → u x = 0
huv : Tendsto (u / v) l (𝓝 1)
⊢ u ~[l] v
state_after: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x = 0 → u x = 0
huv : Tendsto (u / v) l (𝓝 1)
⊢ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v

tactic: exact ⟨u / v, huv, hz.mono fun x hz' ↦ (div_mul_cancel_of_imp hz').symm⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x = 0 → u x = 0
huv : Tendsto (u / v) l (𝓝 1)
⊢ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v
state_after: no goals
Theorem: EisensteinSeries.auxbound1
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: rcases z with ⟨z, hz⟩
state_before: z : ℍ
c d : ℝ
hc : 1 ≤ c ^ 2
⊢ r z ≤ Complex.abs (↑c * ↑z + ↑d)
state_after: case mk
c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ r ⟨z, hz⟩ ≤ Complex.abs (↑c * ↑⟨z, hz⟩ + ↑d)

tactic: have H1 : z.im ≤ √((c * z.re + d) ^ 2 + (c * z).im ^ 2) := by
  rw [Real.le_sqrt' hz, im_ofReal_mul, mul_pow]
  exact (le_mul_of_one_le_left (sq_nonneg _) hc).trans <| le_add_of_nonneg_left (sq_nonneg _)
state_before: case mk
c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ r ⟨z, hz⟩ ≤ Complex.abs (↑c * ↑⟨z, hz⟩ + ↑d)
state_after: case mk
c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
H1 : z.im ≤ √((c * z.re + d) ^ 2 + (↑c * z).im ^ 2)
⊢ r ⟨z, hz⟩ ≤ Complex.abs (↑c * ↑⟨z, hz⟩ + ↑d)

tactic: simpa only [r, abs_apply, normSq_apply, add_re, re_ofReal_mul, coe_re, ← pow_two, add_im, mul_im,
  coe_im, ofReal_im, zero_mul, add_zero, min_le_iff] using Or.inl H1
state_before: case mk
c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
H1 : z.im ≤ √((c * z.re + d) ^ 2 + (↑c * z).im ^ 2)
⊢ r ⟨z, hz⟩ ≤ Complex.abs (↑c * ↑⟨z, hz⟩ + ↑d)
state_after: no goals

tactic: rw [Real.le_sqrt' hz, im_ofReal_mul, mul_pow]
state_before: c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ z.im ≤ √((c * z.re + d) ^ 2 + (↑c * z).im ^ 2)
state_after: c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ z.im ^ 2 ≤ (c * z.re + d) ^ 2 + c ^ 2 * z.im ^ 2

tactic: exact (le_mul_of_one_le_left (sq_nonneg _) hc).trans <| le_add_of_nonneg_left (sq_nonneg _)
state_before: c d : ℝ
hc : 1 ≤ c ^ 2
z : ℂ
hz : 0 < z.im
⊢ z.im ^ 2 ≤ (c * z.re + d) ^ 2 + c ^ 2 * z.im ^ 2
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.tensor_hom_inv_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, f.hom_inv_id]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f.hom) ≫ (h ⊗ f.inv) = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)

tactic: simp [tensorHom_id]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: no goals
Theorem: SNum.bit_zero
File: Mathlib/Data/Num/Bitwise.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b::zero b) = zero b
state_after: no goals
Theorem: TypeVec.repeatEq_iff_eq
File: Mathlib/Data/TypeVec.lean

tactic: induction' i with _ _ _ i_ih
state_before: n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x y : α i
⊢ ofRepeat (α.repeatEq i (prod.mk i x y)) ↔ x = y
state_after: case fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x y : α Fin2.fz
⊢ ofRepeat (α.repeatEq Fin2.fz (prod.mk Fin2.fz x y)) ↔ x = y

case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} {x y : α a✝}, ofRepeat (α.repeatEq a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec.{u_1} (n✝ + 1)
x y : α a✝.fs
⊢ ofRepeat (α.repeatEq a✝.fs (prod.mk a✝.fs x y)) ↔ x = y

tactic: erw [repeatEq, i_ih]
state_before: case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} {x y : α a✝}, ofRepeat (α.repeatEq a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec.{u_1} (n✝ + 1)
x y : α a✝.fs
⊢ ofRepeat (α.repeatEq a✝.fs (prod.mk a✝.fs x y)) ↔ x = y
state_after: no goals

tactic: rfl
state_before: case fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x y : α Fin2.fz
⊢ ofRepeat (α.repeatEq Fin2.fz (prod.mk Fin2.fz x y)) ↔ x = y
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.mkMetric'.eq_iSup_nat
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: ext1 s
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s : Set X
m : Set X → ℝ≥0∞
⊢ mkMetric' m = ⨆ n, pre m (↑n)⁻¹
state_after: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ (mkMetric' m) s = (⨆ n, pre m (↑n)⁻¹) s

tactic: rw [iSup_apply]
state_before: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ (mkMetric' m) s = (⨆ n, pre m (↑n)⁻¹) s
state_after: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ (mkMetric' m) s = ⨆ i, (pre m (↑i)⁻¹) s

tactic: refine tendsto_nhds_unique (mkMetric'.tendsto_pre_nat m s)
  (tendsto_atTop_iSup fun k l hkl => mkMetric'.mono_pre_nat m hkl s)
state_before: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m✝ : Set X → ℝ≥0∞
r : ℝ≥0∞
μ : OuterMeasure X
s✝ : Set X
m : Set X → ℝ≥0∞
s : Set X
⊢ (mkMetric' m) s = ⨆ i, (pre m (↑i)⁻¹) s
state_after: no goals
Theorem: DFinsupp.single_add_erase
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: subst h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : i = i'
⊢ (single i (f i) + erase i f) i' = f i'
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
⊢ (single i (f i) + erase i f) i = f i

tactic: simp only [add_apply, single_apply, erase_apply, add_zero, dite_eq_ite, if_true]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
⊢ (single i (f i) + erase i f) i = f i
state_after: no goals

tactic: simp only [add_apply, single_apply, erase_apply, dif_neg h, if_neg (Ne.symm h), zero_add]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : ¬i = i'
⊢ (single i (f i) + erase i f) i' = f i'
state_after: no goals
Theorem: NFA.toεNFA_correct
File: Mathlib/Computability/EpsilonNFA.lean

tactic: rw [εNFA.accepts, εNFA.eval, toεNFA_evalFrom_match]
state_before: α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S : Set σ
x : List α
s : σ
a : α
M : NFA α σ
⊢ M.toεNFA.accepts = M.accepts
state_after: α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S : Set σ
x : List α
s : σ
a : α
M : NFA α σ
⊢ {x | ∃ S ∈ M.toεNFA.accept, S ∈ M.evalFrom M.toεNFA.start x} = M.accepts

tactic: rfl
state_before: α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S : Set σ
x : List α
s : σ
a : α
M : NFA α σ
⊢ {x | ∃ S ∈ M.toεNFA.accept, S ∈ M.evalFrom M.toεNFA.start x} = M.accepts
state_after: no goals
Theorem: Rat.not_secondCountableTopology_opc
File: Mathlib/Topology/Instances/RatLemmas.lean

tactic: intro
state_before: p q : ℚ
s t : Set ℚ
⊢ ¬SecondCountableTopology ℚ∞
state_after: p q : ℚ
s t : Set ℚ
a✝ : SecondCountableTopology ℚ∞
⊢ False

tactic: exact not_firstCountableTopology_opc inferInstance
state_before: p q : ℚ
s t : Set ℚ
a✝ : SecondCountableTopology ℚ∞
⊢ False
state_after: no goals
Theorem: Nat.factorization_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext p
state_before: a✝ b✝ m n p a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (a * b).factorization = a.factorization + b.factorization
state_after: case h
a✝ b✝ m n p✝ a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ (a * b).factorization p = (a.factorization + b.factorization) p

tactic: simp only [add_apply, ← factors_count_eq, perm_iff_count.mp (perm_factors_mul ha hb) p,
  count_append]
state_before: case h
a✝ b✝ m n p✝ a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ (a * b).factorization p = (a.factorization + b.factorization) p
state_after: no goals