1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.HasTemperateGrowth.zero
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

tactic: refine ⟨contDiff_const, fun n ↦ ⟨0, 0, fun x ↦ ?_⟩⟩
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
⊢ Function.HasTemperateGrowth fun x => 0
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ ‖iteratedFDeriv ℝ n (fun x => 0) x‖ ≤ 0 * (1 + ‖x‖) ^ 0

tactic: simp only [iteratedFDeriv_zero_fun, Pi.zero_apply, norm_zero, forall_const]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ ‖iteratedFDeriv ℝ n (fun x => 0) x‖ ≤ 0 * (1 + ‖x‖) ^ 0
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ 0 ≤ 0 * (1 + ‖x‖) ^ 0

tactic: positivity
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
n : ℕ
x : E
⊢ 0 ≤ 0 * (1 + ‖x‖) ^ 0
state_after: no goals
Theorem: List.getElem?_iterate
File: Mathlib/Data/List/Iterate.lean

tactic: simp
state_before: α : Type u_1
f : α → α
a : α
n : ℕ
x✝ : 0 < n + 1
⊢ (iterate f a (n + 1))[0]? = some (f^[0] a)
state_after: no goals

tactic: simp [getElem?_iterate f (f a) n i (by simpa using h)]
state_before: α : Type u_1
f : α → α
a : α
n i : ℕ
h : i + 1 < n + 1
⊢ (iterate f a (n + 1))[i + 1]? = some (f^[i + 1] a)
state_after: no goals

tactic: simpa using h
state_before: α : Type u_1
f : α → α
a : α
n i : ℕ
h : i + 1 < n + 1
⊢ i < n
state_after: no goals
Theorem: Complex.sub_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [two_mul, sub_eq_add_neg, ofReal']
state_before: z : ℂ
⊢ (z - (starRingEnd ℂ) z).re = (↑(2 * z.im) * I).re ∧ (z - (starRingEnd ℂ) z).im = (↑(2 * z.im) * I).im
state_after: no goals
Theorem: generateFrom_generatePiSystem_eq
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: apply le_antisymm <;> apply generateFrom_le
state_before: α : Type u_1
g : Set (Set α)
⊢ generateFrom (generatePiSystem g) = generateFrom g
state_after: case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ t ∈ generatePiSystem g, MeasurableSet t

case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ t ∈ g, MeasurableSet t

tactic: exact fun t h_t => generateFrom_measurableSet_of_generatePiSystem t h_t
state_before: case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ t ∈ generatePiSystem g, MeasurableSet t
state_after: no goals

tactic: exact fun t h_t => measurableSet_generateFrom (generatePiSystem.base h_t)
state_before: case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ t ∈ g, MeasurableSet t
state_after: no goals
Theorem: Set.sInter_eq_compl_sUnion_compl
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← compl_compl (⋂₀ S), compl_sInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
S : Set (Set α)
⊢ ⋂₀ S = (⋃₀ (compl '' S))ᶜ
state_after: no goals
Theorem: Set.preimage_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: simp only [preimage_boolIndicator_eq_union]
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ s.boolIndicator ⁻¹' t = univ ∨ s.boolIndicator ⁻¹' t = s ∨ s.boolIndicator ⁻¹' t = sᶜ ∨ s.boolIndicator ⁻¹' t = ∅
state_after: α : Type u_1
s : Set α
t : Set Bool
⊢ ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = univ ∨
    ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = s ∨
      ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = sᶜ ∨
        ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = ∅

tactic: split_ifs <;> simp [s.union_compl_self]
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = univ ∨
    ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = s ∨
      ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = sᶜ ∨
        ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = ∅
state_after: no goals
Theorem: nhdsWithin_Iic_basis'
File: Mathlib/Topology/Order/Basic.lean

tactic: convert nhdsWithin_Ici_basis' (α := αᵒᵈ) ha using 2
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
⊢ (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Ioc l a
state_after: case h.e'_5.h.h
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
e_1✝ : α = αᵒᵈ
x✝ : α
⊢ Ioc x✝ a = Ico a x✝

tactic: exact dual_Ico.symm
state_before: case h.e'_5.h.h
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
e_1✝ : α = αᵒᵈ
x✝ : α
⊢ Ioc x✝ a = Ico a x✝
state_after: no goals
Theorem: Filter.Tendsto.prod_map_prod_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atTop_atTop_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atTop ×ˢ atTop)

tactic: exact hf.prod_map hg
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atTop ×ˢ atTop)
state_after: no goals
Theorem: MeasureTheory.Measure.lintegral_rnDeriv_lt_top_of_measure_ne_top
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hl : HaveLebesgueDecomposition μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤

tactic: suffices (∫⁻ x in toMeasurable μ s, μ.rnDeriv ν x ∂ν) < ∞ from
  lt_of_le_of_lt (lintegral_mono_set (subset_toMeasurable _ _)) this
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in toMeasurable μ s, μ.rnDeriv ν x ∂ν < ⊤

tactic: rw [← withDensity_apply _ (measurableSet_toMeasurable _ _)]
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in toMeasurable μ s, μ.rnDeriv ν x ∂ν < ⊤
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ (ν.withDensity (μ.rnDeriv ν)) (toMeasurable μ s) < ⊤

tactic: calc
  _ ≤ (singularPart μ ν) (toMeasurable μ s) + _ := le_add_self
  _ = μ s := by rw [← Measure.add_apply, ← haveLebesgueDecomposition_add, measure_toMeasurable]
  _ < ⊤ := hs.lt_top
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ (ν.withDensity (μ.rnDeriv ν)) (toMeasurable μ s) < ⊤
state_after: no goals

tactic: rw [← Measure.add_apply, ← haveLebesgueDecomposition_add, measure_toMeasurable]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : μ.HaveLebesgueDecomposition ν
⊢ (μ.singularPart ν) (toMeasurable μ s) + (ν.withDensity (μ.rnDeriv ν)) (toMeasurable μ s) = μ s
state_after: no goals

tactic: simp only [Measure.rnDeriv, dif_neg hl, Pi.zero_apply, lintegral_zero, ENNReal.zero_lt_top]
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν✝ ν : Measure α
s : Set α
hs : μ s ≠ ⊤
hl : ¬μ.HaveLebesgueDecomposition ν
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤
state_after: no goals
Theorem: Filter.pure_bind
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Bind.bind, bind, map_pure, join_pure]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
a : α
m : α → Filter β
⊢ (pure a).bind m = m a
state_after: no goals
Theorem: ProbabilityTheory.condCount_self
File: Mathlib/Probability/CondCount.lean

tactic: rw [condCount, cond_apply _ hs.measurableSet, Set.inter_self, ENNReal.inv_mul_cancel]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ (condCount s) s = 1
state_after: case h0
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ Measure.count s ≠ 0

case ht
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ Measure.count s ≠ ⊤

tactic: exact fun h => hs'.ne_empty <| Measure.empty_of_count_eq_zero h
state_before: case h0
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ Measure.count s ≠ 0
state_after: no goals

tactic: exact (Measure.count_apply_lt_top.2 hs).ne
state_before: case ht
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ Measure.count s ≠ ⊤
state_after: no goals
Theorem: Nat.clog_pow
File: Mathlib/Data/Nat/Log.lean

tactic: rw [← le_pow_iff_clog_le hb, Nat.pow_le_pow_iff_right hb]
state_before: b x : ℕ
hb : 1 < b
z : ℕ
⊢ clog b (b ^ x) ≤ z ↔ x ≤ z
state_after: no goals
Theorem: Submodule.fst_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_bot_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (fst R M M₂) = ⊥
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (fst R M M₂) ≤ ⊥

tactic: intro x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (snd R M M₂) (fst R M M₂) ≤ ⊥
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (snd R M M₂) (fst R M M₂) → x ∈ ⊥

tactic: simp only [fst, comap_bot, mem_map, mem_ker, snd_apply, eq_comm, Prod.exists, exists_eq_left,
  exists_const, mem_bot, imp_self]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (snd R M M₂) (fst R M M₂) → x ∈ ⊥
state_after: no goals
Theorem: NormedAddGroupHom.Equalizer.map_comp_map
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : ψ.comp f₁ = f₂.comp φ
hg : ψ.comp g₁ = g₂.comp φ
hf' : ψ'.comp f₂ = f₃.comp φ'
hg' : ψ'.comp g₂ = g₃.comp φ'
⊢ (map φ' ψ' hf' hg').comp (map φ ψ hf hg) = map (φ'.comp φ) (ψ'.comp ψ) ⋯ ⋯
state_after: case H.a
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : ψ.comp f₁ = f₂.comp φ
hg : ψ.comp g₁ = g₂.comp φ
hf' : ψ'.comp f₂ = f₃.comp φ'
hg' : ψ'.comp g₂ = g₃.comp φ'
x✝ : ↥(f₁.equalizer g₁)
⊢ ↑(((map φ' ψ' hf' hg').comp (map φ ψ hf hg)) x✝) = ↑((map (φ'.comp φ) (ψ'.comp ψ) ⋯ ⋯) x✝)

tactic: rfl
state_before: case H.a
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : ψ.comp f₁ = f₂.comp φ
hg : ψ.comp g₁ = g₂.comp φ
hf' : ψ'.comp f₂ = f₃.comp φ'
hg' : ψ'.comp g₂ = g₃.comp φ'
x✝ : ↥(f₁.equalizer g₁)
⊢ ↑(((map φ' ψ' hf' hg').comp (map φ ψ hf hg)) x✝) = ↑((map (φ'.comp φ) (ψ'.comp ψ) ⋯ ⋯) x✝)
state_after: no goals
Theorem: not_isRightRegular_zero_iff
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rw [nontrivial_iff, not_iff_comm, isRightRegular_zero_iff_subsingleton, subsingleton_iff]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ ¬IsRightRegular 0 ↔ Nontrivial R
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (¬∃ x y, x ≠ y) ↔ ∀ (x y : R), x = y

tactic: push_neg
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (¬∃ x y, x ≠ y) ↔ ∀ (x y : R), x = y
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (∀ (x y : R), x = y) ↔ ∀ (x y : R), x = y

tactic: exact Iff.rfl
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (∀ (x y : R), x = y) ↔ ∀ (x y : R), x = y
state_after: no goals
Theorem: ContinuousLinearMap.opNorm_le_bound'
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean

tactic: simp only [h, mul_zero, norm_image_of_norm_zero f f.2 h, le_refl]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝¹ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝ : FunLike 𝓕 E F
f : E →SL[σ₁₂] F
M : ℝ
hMp : 0 ≤ M
hM : ∀ (x : E), ‖x‖ ≠ 0 → ‖f x‖ ≤ M * ‖x‖
x : E
h : ‖x‖ = 0
⊢ ‖f x‖ ≤ M * ‖x‖
state_after: no goals
Theorem: Matrix.charpoly.univ_map_eval₂Hom
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Univ.lean

tactic: rw [univ, ← charpoly_map, coe_eval₂Hom, ← mvPolynomialX_map_eval₂ f (Matrix.of M.curry)]
state_before: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ Polynomial.map (eval₂Hom f M) (univ R n) = (of (Function.curry M)).charpoly
state_after: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ ((mvPolynomialX n n R).map (eval₂ f M)).charpoly =
    ((mvPolynomialX n n R).map (eval₂ f fun p => of (Function.curry M) p.1 p.2)).charpoly

tactic: simp only [of_apply, Function.curry_apply, Prod.mk.eta]
state_before: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ ((mvPolynomialX n n R).map (eval₂ f M)).charpoly =
    ((mvPolynomialX n n R).map (eval₂ f fun p => of (Function.curry M) p.1 p.2)).charpoly
state_after: no goals
Theorem: Nat.land_assoc
File: Mathlib/Data/Nat/Bitwise.lean

tactic: bitwise_assoc_tac
state_before: n m k : ℕ
⊢ n &&& m &&& k = n &&& (m &&& k)
state_after: no goals
Theorem: Turing.ToPartrec.Code.succ_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ succ.eval = fun v => pure [v.headI.succ]
state_after: no goals
Theorem: AlgHom.card_of_splits
File: Mathlib/FieldTheory/PrimitiveElement.lean

tactic: rw [← Fintype.ofEquiv_card <| Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits
  (AlgebraicClosure L) _ hL]
state_before: F : Type u_1
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : IsSeparable F E
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra F L
hL : ∀ (x : E), Splits (algebraMap F L) (minpoly F x)
⊢ Fintype.card (E →ₐ[F] L) = finrank F E
state_after: F : Type u_1
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : IsSeparable F E
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra F L
hL : ∀ (x : E), Splits (algebraMap F L) (minpoly F x)
⊢ Fintype.card (E →ₐ[F] AlgebraicClosure L) = finrank F E

tactic: convert AlgHom.card F E (AlgebraicClosure L)
state_before: F : Type u_1
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : IsSeparable F E
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra F L
hL : ∀ (x : E), Splits (algebraMap F L) (minpoly F x)
⊢ Fintype.card (E →ₐ[F] AlgebraicClosure L) = finrank F E
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isNat_natAbs_neg
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: a✝ : ℕ
⊢ (↑(Int.negOfNat a✝)).natAbs = ↑a✝
state_after: no goals
Theorem: setOf_liouville_eq_iInter_iUnion
File: Mathlib/NumberTheory/Liouville/Residual.lean

tactic: ext x
state_before: ⊢ {x | Liouville x} = ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
state_after: case h
x : ℝ
⊢ x ∈ {x | Liouville x} ↔ x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: simp only [mem_iInter, mem_iUnion, Liouville, mem_setOf_eq, exists_prop, mem_diff,
  mem_singleton_iff, mem_ball, Real.dist_eq, and_comm]
state_before: case h
x : ℝ
⊢ x ∈ {x | Liouville x} ↔ x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
state_after: no goals
Theorem: cmp_self_eq_eq
File: Mathlib/Order/Compare.lean

tactic: rw [cmp_eq_eq_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
x y : α
⊢ cmp x x = eq
state_after: no goals
Theorem: Metric.thickening_subset_cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: intro x hx
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
E : Set α
⊢ thickening δ E ⊆ cthickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : x ∈ thickening δ E
⊢ x ∈ cthickening δ E

tactic: rw [thickening, mem_setOf_eq] at hx
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : x ∈ thickening δ E
⊢ x ∈ cthickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : infEdist x E < ENNReal.ofReal δ
⊢ x ∈ cthickening δ E

tactic: exact hx.le
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
E : Set α
x : α
hx : infEdist x E < ENNReal.ofReal δ
⊢ x ∈ cthickening δ E
state_after: no goals
Theorem: Polynomial.natDegree_lt_natDegree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: by_cases hq : q = 0
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : p ≠ 0
hpq : p.degree < q.degree
⊢ p.natDegree < q.natDegree
state_after: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : p ≠ 0
hpq : p.degree < q.degree
hq : q = 0
⊢ p.natDegree < q.natDegree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : p ≠ 0
hpq : p.degree < q.degree
hq : ¬q = 0
⊢ p.natDegree < q.natDegree

tactic: rwa [degree_eq_natDegree hp, degree_eq_natDegree hq, Nat.cast_lt] at hpq
state_before: case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : p ≠ 0
hpq : p.degree < q.degree
hq : ¬q = 0
⊢ p.natDegree < q.natDegree
state_after: no goals

tactic: exact (not_lt_bot <| hq ▸ hpq).elim
state_before: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : p ≠ 0
hpq : p.degree < q.degree
hq : q = 0
⊢ p.natDegree < q.natDegree
state_after: no goals
Theorem: RelSeries.head_snoc
File: Mathlib/Order/RelSeries.lean

tactic: delta snoc
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
newLast : α
rel : r p.last newLast
⊢ (p.snoc newLast rel).head = p.head
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
newLast : α
rel : r p.last newLast
⊢ (p.append (singleton r newLast) rel).head = p.head

tactic: rw [head_append]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
newLast : α
rel : r p.last newLast
⊢ (p.append (singleton r newLast) rel).head = p.head
state_after: no goals