1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ico_eq_locus_Ioc_eq_iUnion_Ioo
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: ext1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ {b | toIcoMod hp a b = toIocMod hp a b} = ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)
state_after: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x✝ : α
⊢ x✝ ∈ {b | toIcoMod hp a b = toIocMod hp a b} ↔ x✝ ∈ ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)

tactic: simp_rw [Set.mem_setOf, Set.mem_iUnion, ← Set.sub_mem_Ioo_iff_left, ←
  not_modEq_iff_toIcoMod_eq_toIocMod, modEq_iff_not_forall_mem_Ioo_mod hp, not_forall,
  Classical.not_not]
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x✝ : α
⊢ x✝ ∈ {b | toIcoMod hp a b = toIocMod hp a b} ↔ x✝ ∈ ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)
state_after: no goals
Theorem: Polynomial.eq_of_degree_le_of_eval_finset_eq
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rcases eq_or_ne f 0 with rfl | hf
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
h_deg_le : f.degree ≤ ↑s.card
h_deg_eq : f.degree = g.degree
hlc : f.leadingCoeff = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x f = eval x g
⊢ f = g
state_after: case inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
g : R[X]
s : Finset R
h_deg_le : degree 0 ≤ ↑s.card
h_deg_eq : degree 0 = g.degree
hlc : leadingCoeff 0 = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x 0 = eval x g
⊢ 0 = g

case inr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
h_deg_le : f.degree ≤ ↑s.card
h_deg_eq : f.degree = g.degree
hlc : f.leadingCoeff = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x f = eval x g
hf : f ≠ 0
⊢ f = g

tactic: rwa [degree_zero, eq_comm, degree_eq_bot, eq_comm] at h_deg_eq
state_before: case inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
g : R[X]
s : Finset R
h_deg_le : degree 0 ≤ ↑s.card
h_deg_eq : degree 0 = g.degree
hlc : leadingCoeff 0 = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x 0 = eval x g
⊢ 0 = g
state_after: no goals

tactic: exact eq_of_degree_sub_lt_of_eval_finset_eq s
  (lt_of_lt_of_le (degree_sub_lt h_deg_eq hf hlc) h_deg_le) h_eval
state_before: case inr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
h_deg_le : f.degree ≤ ↑s.card
h_deg_eq : f.degree = g.degree
hlc : f.leadingCoeff = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x f = eval x g
hf : f ≠ 0
⊢ f = g
state_after: no goals
Theorem: CanonicallyOrderedCommSemiring.mul_lt_mul_of_lt_of_lt
File: Mathlib/Algebra/Order/Ring/Canonical.lean

tactic: have := posMulStrictMono_iff_mulPosStrictMono.1 ‹_›
state_before: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
⊢ a * c < b * d
state_after: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
⊢ a * c < b * d

tactic: obtain rfl | hc := eq_zero_or_pos c
state_before: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
⊢ a * c < b * d
state_after: case inl
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b d : α
inst✝ : PosMulStrictMono α
hab : a < b
this : MulPosStrictMono α
hcd : 0 < d
⊢ a * 0 < b * d

case inr
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
hc : 0 < c
⊢ a * c < b * d

tactic: rw [mul_zero]
state_before: case inl
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b d : α
inst✝ : PosMulStrictMono α
hab : a < b
this : MulPosStrictMono α
hcd : 0 < d
⊢ a * 0 < b * d
state_after: case inl
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b d : α
inst✝ : PosMulStrictMono α
hab : a < b
this : MulPosStrictMono α
hcd : 0 < d
⊢ 0 < b * d

tactic: exact mul_pos ((zero_le _).trans_lt hab) hcd
state_before: case inl
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b d : α
inst✝ : PosMulStrictMono α
hab : a < b
this : MulPosStrictMono α
hcd : 0 < d
⊢ 0 < b * d
state_after: no goals

tactic: exact mul_lt_mul_of_lt_of_lt' hab hcd ((zero_le _).trans_lt hab) hc
state_before: case inr
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : PosMulStrictMono α
hab : a < b
hcd : c < d
this : MulPosStrictMono α
hc : 0 < c
⊢ a * c < b * d
state_after: no goals
Theorem: vectorSpan_image_eq_span_vsub_set_left_ne
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: conv_lhs =>
  rw [vectorSpan_eq_span_vsub_set_left k (Set.mem_image_of_mem p hi), ← Set.insert_eq_of_mem hi, ←
    Set.insert_diff_singleton, Set.image_insert_eq, Set.image_insert_eq]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
s : Set ι
i : ι
hi : i ∈ s
⊢ vectorSpan k (p '' s) = Submodule.span k ((fun x => p i -ᵥ x) '' (p '' (s \ {i})))
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
s : Set ι
i : ι
hi : i ∈ s
⊢ Submodule.span k (insert (p i -ᵥ p i) ((fun x => p i -ᵥ x) '' (p '' (s \ {i})))) =
    Submodule.span k ((fun x => p i -ᵥ x) '' (p '' (s \ {i})))

tactic: simp [Submodule.span_insert_eq_span]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
s : Set ι
i : ι
hi : i ∈ s
⊢ Submodule.span k (insert (p i -ᵥ p i) ((fun x => p i -ᵥ x) '' (p '' (s \ {i})))) =
    Submodule.span k ((fun x => p i -ᵥ x) '' (p '' (s \ {i})))
state_after: no goals
Theorem: Grp.isZero_of_subsingleton
File: Mathlib/Algebra/Category/Grp/Zero.lean

tactic: refine ⟨fun X => ⟨⟨⟨1⟩, fun f => ?_⟩⟩, fun X => ⟨⟨⟨1⟩, fun f => ?_⟩⟩⟩
state_before: G : Grp
inst✝ : Subsingleton ↑G
⊢ IsZero G
state_after: case refine_1
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
⊢ f = default

case refine_2
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : X ⟶ G
⊢ f = default

tactic: ext x
state_before: case refine_1
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
⊢ f = default
state_after: case refine_1.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
x : ↑G
⊢ f x = default x

tactic: have : x = 1 := Subsingleton.elim _ _
state_before: case refine_1.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
x : ↑G
⊢ f x = default x
state_after: case refine_1.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
x : ↑G
this : x = 1
⊢ f x = default x

tactic: rw [this, map_one, map_one]
state_before: case refine_1.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : G ⟶ X
x : ↑G
this : x = 1
⊢ f x = default x
state_after: no goals

tactic: ext
state_before: case refine_2
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : X ⟶ G
⊢ f = default
state_after: case refine_2.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : X ⟶ G
x✝ : ↑X
⊢ f x✝ = default x✝

tactic: apply Subsingleton.elim
state_before: case refine_2.w
G : Grp
inst✝ : Subsingleton ↑G
X : Grp
f : X ⟶ G
x✝ : ↑X
⊢ f x✝ = default x✝
state_after: no goals
Theorem: SimpleGraph.Walk.start_mem_verts_toSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [mem_verts_toSubgraph]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
⊢ u ∈ p.toSubgraph.verts
state_after: no goals
Theorem: hammingDist_triangle_left
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [hammingDist_comm z]
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist z x + hammingDist z y
state_after: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist x z + hammingDist z y

tactic: exact hammingDist_triangle _ _ _
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist x z + hammingDist z y
state_after: no goals
Theorem: Set.exists_eq_graphOn
File: Mathlib/Data/Set/Function.lean

tactic: rw [hs, image_fst_graphOn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
inst✝ : Nonempty β
s : Set (α × β)
x✝ : ∃ f t, s = graphOn f t
f : α → β
t : Set α
hs : s = graphOn f t
⊢ s = graphOn f (Prod.fst '' s)
state_after: no goals
Theorem: Metric.infDist_zero_of_mem
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [infEdist_zero_of_mem h, infDist]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : x ∈ s
⊢ infDist x s = 0
state_after: no goals
Theorem: AkraBazziRecurrence.deriv_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: have : log x ≠ 0 := Real.log_ne_zero_of_pos_of_ne_one (by positivity) (ne_of_gt hx)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv ε x = -x⁻¹ / log x ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv ε x = -x⁻¹ / log x ^ 2

tactic: show deriv (fun z => 1 / log z) x = -x⁻¹ / (log x ^ 2)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv ε x = -x⁻¹ / log x ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv (fun z => 1 / log z) x = -x⁻¹ / log x ^ 2

tactic: rw [deriv_div] <;> aesop
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv (fun z => 1 / log z) x = -x⁻¹ / log x ^ 2
state_after: no goals

tactic: positivity
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ 0 < x
state_after: no goals
Theorem: Ordnode.size_balanceL
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balanceL_eq_balance' hl hr sl sr H, size_balance' sl sr]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Balanced
hr : r.Balanced
sl : l.Sized
sr : r.Sized
H : (∃ l', Raised l' l.size ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r.size r' ∧ BalancedSz l.size r'
⊢ (l.balanceL x r).size = l.size + r.size + 1
state_after: no goals
Theorem: OmegaCompletePartialOrder.ContinuousHom.ωSup_apply_ωSup
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp [Prod.apply_apply, Prod.ωSup_zip]
state_before: α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
c₀ : Chain (α →𝒄 β)
c₁ : Chain α
⊢ (ωSup c₀) (ωSup c₁) = Prod.apply (ωSup (c₀.zip c₁))
state_after: no goals
Theorem: WithLp.prod_norm_eq_of_nat
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: have := p.toReal_pos_iff_ne_top.mpr (ne_of_eq_of_ne h <| ENNReal.natCast_ne_top n)
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
this : 0 < p.toReal
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)

tactic: simp only [one_div, h, Real.rpow_natCast, ENNReal.toReal_nat, eq_self_iff_true, Finset.sum_congr,
  prod_norm_eq_add this]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : Norm α
inst✝ : Norm β
n : ℕ
h : p = ↑n
f : WithLp p (α × β)
this : 0 < p.toReal
⊢ ‖f‖ = (‖f.1‖ ^ n + ‖f.2‖ ^ n) ^ (1 / ↑n)
state_after: no goals
Theorem: CategoryTheory.OverPresheafAux.MakesOverArrow.map₂
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

tactic: rw [elementwise_of% η.naturality, h.app, yonedaEquiv_naturality, hst]
state_before: C : Type u
inst✝ : Category.{v, u} C
A F : Cᵒᵖ ⥤ Type v
η : F ⟶ A
X Y : C
f : X ⟶ Y
s : yoneda.obj X ⟶ A
t : yoneda.obj Y ⟶ A
hst : yoneda.map f ≫ t = s
u : F.obj { unop := Y }
h : MakesOverArrow η t u
⊢ η.app { unop := X } (F.map f.op u) = yonedaEquiv s
state_after: no goals
Theorem: le_induced_generateFrom
File: Mathlib/Topology/Order.lean

tactic: rw [induced_generateFrom_eq]
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ t ≤ induced f (generateFrom b)
state_after: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ t ≤ generateFrom (preimage f '' b)

tactic: apply le_generateFrom
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ t ≤ generateFrom (preimage f '' b)
state_after: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ ∀ s ∈ preimage f '' b, IsOpen s

tactic: simp only [mem_image, and_imp, forall_apply_eq_imp_iff₂, exists_imp]
state_before: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ ∀ s ∈ preimage f '' b, IsOpen s
state_after: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ ∀ a ∈ b, IsOpen (f ⁻¹' a)

tactic: exact h
state_before: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ a ∈ b, IsOpen (f ⁻¹' a)
⊢ ∀ a ∈ b, IsOpen (f ⁻¹' a)
state_after: no goals
Theorem: Metric.cthickening_eq_iInter_thickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: apply cthickening_eq_iInter_thickening' δ_nn (Ioi δ) rfl.subset
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ cthickening δ E = ⋂ ε, ⋂ (_ : δ < ε), thickening ε E
state_after: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioi δ ∩ Ioc δ ε).Nonempty

tactic: simp_rw [inter_eq_right.mpr Ioc_subset_Ioi_self]
state_before: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioi δ ∩ Ioc δ ε).Nonempty
state_after: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioc δ ε).Nonempty

tactic: exact fun _ hε => nonempty_Ioc.mpr hε
state_before: case hs
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → (Ioc δ ε).Nonempty
state_after: no goals
Theorem: HilbertBasis.finite_spans_dense
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simp_rw [← Submodule.span_iUnion]
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
⊢ (span 𝕜 (Set.range fun i => b.repr.symm (lp.single 2 i 1))).topologicalClosure ≤
    (⨆ J, span 𝕜 ↑(Finset.image (fun i => b.repr.symm (lp.single 2 i 1)) J)).topologicalClosure
state_after: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
⊢ (span 𝕜 (Set.range fun i => b.repr.symm (lp.single 2 i 1))).topologicalClosure ≤
    (span 𝕜 (⋃ i, ↑(Finset.image (fun i => b.repr.symm (lp.single 2 i 1)) i))).topologicalClosure

tactic: exact topologicalClosure_mono (span_mono <| Set.range_subset_iff.mpr fun i =>
  Set.mem_iUnion_of_mem {i} <| Finset.mem_coe.mpr <| Finset.mem_image_of_mem _ <|
  Finset.mem_singleton_self i)
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
⊢ (span 𝕜 (Set.range fun i => b.repr.symm (lp.single 2 i 1))).topologicalClosure ≤
    (span 𝕜 (⋃ i, ↑(Finset.image (fun i => b.repr.symm (lp.single 2 i 1)) i))).topologicalClosure
state_after: no goals
Theorem: WithLp.prod_norm_eq_card
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: convert if_pos rfl
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : Norm α
inst✝ : Norm β
f : WithLp 0 (α × β)
⊢ ‖f‖ = (if ‖f.1‖ = 0 then 0 else 1) + if ‖f.2‖ = 0 then 0 else 1
state_after: no goals
Theorem: IsLocalization.mk'_pow
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: simp_rw [IsLocalization.mk'_eq_iff_eq_mul, SubmonoidClass.coe_pow, map_pow, ← mul_pow]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ mk' S (x ^ n) (y ^ n) = mk' S x y ^ n
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ (algebraMap R S) x ^ n = (mk' S x y * (algebraMap R S) ↑y) ^ n

tactic: simp
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ (algebraMap R S) x ^ n = (mk' S x y * (algebraMap R S) ↑y) ^ n
state_after: no goals
Theorem: Nat.Primrec'.head
File: Mathlib/Computability/Primrec.lean

tactic: simp [get_zero]
state_before: n : ℕ
v : Vector ℕ n.succ
⊢ v.get 0 = v.head
state_after: no goals
Theorem: Int.ceil_pos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [lt_ceil, cast_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ 0 < ⌈a⌉ ↔ 0 < a
state_after: no goals
Theorem: not_differentiableAt_of_local_left_inverse_hasDerivAt_zero
File: Mathlib/Analysis/Calculus/Deriv/Inverse.lean

tactic: intro hg
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
⊢ ¬DifferentiableAt 𝕜 g a
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
⊢ False

tactic: have := (hf.comp a hg.hasDerivAt).congr_of_eventuallyEq hfg.symm
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
⊢ False
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
this : HasDerivAt id (0 * deriv g a) a
⊢ False

tactic: simpa using this.unique (hasDerivAt_id a)
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g✝ : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f g : 𝕜 → 𝕜
a : 𝕜
hf : HasDerivAt f 0 (g a)
hfg : f ∘ g =ᶠ[𝓝 a] id
hg : DifferentiableAt 𝕜 g a
this : HasDerivAt id (0 * deriv g a) a
⊢ False
state_after: no goals
Theorem: CliffordAlgebra.evenOdd_map_reverse
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: simp_rw [evenOdd, Submodule.map_iSup, submodule_map_pow_reverse, ι_range_map_reverse]
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
n : ZMod 2
⊢ Submodule.map reverse (evenOdd Q n) = evenOdd Q n
state_after: no goals
Theorem: TopCat.mono_iff_injective
File: Mathlib/Topology/Category/TopCat/EpiMono.lean

tactic: suffices Mono f ↔ Mono ((forget TopCat).map f) by
  rw [this, CategoryTheory.mono_iff_injective]
  rfl
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Mono f ↔ Function.Injective ⇑f
state_after: X Y : TopCat
f : X ⟶ Y
⊢ Mono f ↔ Mono ((forget TopCat).map f)

tactic: constructor
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Mono f ↔ Mono ((forget TopCat).map f)
state_after: case mp
X Y : TopCat
f : X ⟶ Y
⊢ Mono f → Mono ((forget TopCat).map f)

case mpr
X Y : TopCat
f : X ⟶ Y
⊢ Mono ((forget TopCat).map f) → Mono f

tactic: rw [this, CategoryTheory.mono_iff_injective]
state_before: X Y : TopCat
f : X ⟶ Y
this : Mono f ↔ Mono ((forget TopCat).map f)
⊢ Mono f ↔ Function.Injective ⇑f
state_after: X Y : TopCat
f : X ⟶ Y
this : Mono f ↔ Mono ((forget TopCat).map f)
⊢ Function.Injective ((forget TopCat).map f) ↔ Function.Injective ⇑f

tactic: rfl
state_before: X Y : TopCat
f : X ⟶ Y
this : Mono f ↔ Mono ((forget TopCat).map f)
⊢ Function.Injective ((forget TopCat).map f) ↔ Function.Injective ⇑f
state_after: no goals

tactic: intro
state_before: case mp
X Y : TopCat
f : X ⟶ Y
⊢ Mono f → Mono ((forget TopCat).map f)
state_after: case mp
X Y : TopCat
f : X ⟶ Y
a✝ : Mono f
⊢ Mono ((forget TopCat).map f)

tactic: infer_instance
state_before: case mp
X Y : TopCat
f : X ⟶ Y
a✝ : Mono f
⊢ Mono ((forget TopCat).map f)
state_after: no goals

tactic: apply Functor.mono_of_mono_map
state_before: case mpr
X Y : TopCat
f : X ⟶ Y
⊢ Mono ((forget TopCat).map f) → Mono f
state_after: no goals