tasksource/leandojo huggingface dataset:
Theorem: List.nodup_replicate
File: Mathlib/Data/List/Nodup.lean

tactic: simp [Nat.zero_le]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a✝ b a : α
⊢ Nodup (replicate 0 a) ↔ 0 ≤ 1

tactic: simp
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a✝ b a : α
⊢ Nodup (replicate 1 a) ↔ 1 ≤ 1
Theorem: List.Perm.prod_eq'
File: Mathlib/Data/List/Perm.lean

tactic: refine h.foldl_eq' ?_ _
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ prod l₁ = prod l₂

tactic: apply Pairwise.forall_of_forall
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₁ → ∀ (z : α), z * x * y = z * y * x

tactic: . intro x y h z
  exact (h z).symm
state_before: case H
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Symmetric fun x y => ∀ (z : α), z * x * y = z * y * x

case H₁
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ (x : α), x ∈ l₁ → ∀ (z : α), z * x * x = z * x * x

case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Pairwise (fun x y => ∀ (z : α), z * x * y = z * y * x) l₁

tactic: . intros; rfl
state_before: case H₁
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ (x : α), x ∈ l₁ → ∀ (z : α), z * x * x = z * x * x

case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Pairwise (fun x y => ∀ (z : α), z * x * y = z * y * x) l₁

tactic: . apply hc.imp
  intro a b h z
  rw [mul_assoc z, mul_assoc z, h]
state_before: case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Pairwise (fun x y => ∀ (z : α), z * x * y = z * y * x) l₁

tactic: intro x y h z
state_before: case H
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Symmetric fun x y => ∀ (z : α), z * x * y = z * y * x

tactic: exact (h z).symm
state_before: case H
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h✝ : l₁ ~ l₂
hc : Pairwise Commute l₁
x y : α
h : ∀ (z : α), z * x * y = z * y * x
z : α
⊢ z * y * x = z * x * y

tactic: intros
state_before: case H₁
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ (x : α), x ∈ l₁ → ∀ (z : α), z * x * x = z * x * x

tactic: rfl
state_before: case H₁
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
x✝ : α
a✝ : x✝ ∈ l₁
z✝ : α
⊢ z✝ * x✝ * x✝ = z✝ * x✝ * x✝

tactic: apply hc.imp
state_before: case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Pairwise (fun x y => ∀ (z : α), z * x * y = z * y * x) l₁

tactic: intro a b h z
state_before: case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ {a b : α}, Commute a b → ∀ (z : α), z * a * b = z * b * a

tactic: rw [mul_assoc z, mul_assoc z, h]
state_before: case H₂
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
M : Monoid α
l₁ l₂ : List α
h✝ : l₁ ~ l₂
hc : Pairwise Commute l₁
a b : α
h : Commute a b
z : α
⊢ z * a * b = z * b * a
Theorem: Finset.image_subset_image_iff
File: Mathlib/Data/Finset/Image.lean

tactic: simp_rw [← coe_subset]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82868
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ image f s ⊆ image f t ↔ s ⊆ t

tactic: push_cast
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82868
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ ↑(image f s) ⊆ ↑(image f t) ↔ ↑s ⊆ ↑t

tactic: exact Set.image_subset_image_iff hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82868
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ f '' ↑s ⊆ f '' ↑t ↔ ↑s ⊆ ↑t
Theorem: Ordinal.log_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: convert log_opow_mul_add hb zero_ne_one.symm hb (opow_pos x (zero_lt_one.trans hb))
  using 1
state_before: b : Ordinal
hb : 1 < b
x : Ordinal
⊢ log b (b ^ x) = x

tactic: rw [add_zero, mul_one]
state_before: case h.e'_2
b : Ordinal
hb : 1 < b
x : Ordinal
⊢ log b (b ^ x) = log b (b ^ x * 1 + 0)
Theorem: Fin.insertNth_apply_same
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [insertNth, succAboveCases]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (↑(succAbove i) j)
⊢ insertNth i x p i = x
Theorem: tendsto_nhds_top_mono
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhds_top_order, tendsto_iInf, tendsto_principal] at hf ⊢
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hf : Tendsto f l (𝓝 ⊤)
hg : f ≤ᶠ[l] g
⊢ Tendsto g l (𝓝 ⊤)

tactic: intro x hx
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ (i : β), i < ⊤ → ∀ᶠ (a : α) in l, f a ∈ Ioi i
⊢ ∀ (i : β), i < ⊤ → ∀ᶠ (a : α) in l, g a ∈ Ioi i

tactic: filter_upwards [hf x hx, hg] with _ using lt_of_lt_of_le
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace β
inst✝² : Preorder β
inst✝¹ : OrderTop β
inst✝ : OrderTopology β
l : Filter α
f g : α → β
hg : f ≤ᶠ[l] g
hf : ∀ (i : β), i < ⊤ → ∀ᶠ (a : α) in l, f a ∈ Ioi i
x : β
hx : x < ⊤
⊢ ∀ᶠ (a : α) in l, g a ∈ Ioi x
Theorem: ENNReal.smul_toNNReal
File: Mathlib/Data/Real/ENNReal.lean

tactic: change ((a : ℝ≥0∞) * b).toNNReal = a * b.toNNReal
state_before: α : Type ?u.819259
β : Type ?u.819262
a✝ b✝ c d : ℝ≥0∞
r p q a : ℝ≥0
b : ℝ≥0∞
⊢ ENNReal.toNNReal (a • b) = a * ENNReal.toNNReal b

tactic: simp only [ENNReal.toNNReal_mul, ENNReal.toNNReal_coe]
state_before: α : Type ?u.819259
β : Type ?u.819262
a✝ b✝ c d : ℝ≥0∞
r p q a : ℝ≥0
b : ℝ≥0∞
⊢ ENNReal.toNNReal (↑a * b) = a * ENNReal.toNNReal b
Theorem: MeasureTheory.measure_union_add_inter₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [← measure_inter_add_diff₀ (s ∪ t) ht, union_inter_cancel_right, union_diff_right, ←
  measure_inter_add_diff₀ s ht, add_comm, ← add_assoc, add_right_comm]
state_before: ι : Type ?u.17157
α : Type u_1
β : Type ?u.17163
γ : Type ?u.17166
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ (s ∪ t) + ↑↑μ (s ∩ t) = ↑↑μ s + ↑↑μ t
Theorem: Polynomial.eval₂_mul_X
File: Mathlib/Data/Polynomial/Eval.lean

tactic: refine' _root_.trans (eval₂_mul_noncomm _ _ fun k => _) (by rw [eval₂_X])
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
⊢ eval₂ f x (p * X) = eval₂ f x p * x

tactic: rcases em (k = 1) with (rfl | hk)
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
k : ℕ
⊢ Commute (↑f (coeff X k)) x

tactic: rw [eval₂_X]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
⊢ eval₂ f x p * eval₂ f x X = eval₂ f x p * x

tactic: simp
state_before: case inl
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
⊢ Commute (↑f (coeff X 1)) x

tactic: simp [coeff_X_of_ne_one hk]
state_before: case inr
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
k : ℕ
hk : ¬k = 1
⊢ Commute (↑f (coeff X k)) x
Theorem: MeasureTheory.memℒp_one_iff_integrable
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [Integrable, HasFiniteIntegral, Memℒp, snorm_one_eq_lintegral_nnnorm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.827340
δ : Type ?u.827343
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ Memℒp f 1 ↔ Integrable f
Theorem: MeasureTheory.set_average_eq
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: rw [average_eq, restrict_apply_univ]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.195874
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ : Measure α
s✝ : Set E
f : α → E
s : Set α
⊢ (⨍ (x : α) in s, f x ∂μ) = (ENNReal.toReal (↑↑μ s))⁻¹ • ∫ (x : α) in s, f x ∂μ
Theorem: Finsupp.support_subset_singleton'
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [hb, support_subset_singleton, single_eq_same]
state_before: α : Type u_1
β : Type ?u.136560
γ : Type ?u.136563
ι : Type ?u.136566
M : Type u_2
M' : Type ?u.136572
N : Type ?u.136575
P : Type ?u.136578
G : Type ?u.136581
H : Type ?u.136584
R : Type ?u.136587
S : Type ?u.136590
inst✝ : Zero M
a✝ a' : α
b✝ : M
f : α →₀ M
a : α
x✝ : ∃ b, f = single a b
b : M
hb : f = single a b
⊢ f.support ⊆ {a}
Theorem: Nat.pow_lt_ascFactorial'
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [pow_succ, ascFactorial, mul_comm]
state_before: n k : ℕ
⊢ (n + 1) ^ (k + 2) < ascFactorial n (k + 2)

tactic: exact
  Nat.mul_lt_mul (Nat.add_lt_add_right (Nat.lt_add_of_pos_right succ_pos') 1)
    (pow_succ_le_ascFactorial n _) (pow_pos succ_pos' _)
state_before: n k : ℕ
⊢ (n + 1) * (n + 1) ^ (k + 1) < (n + (k + 1) + 1) * ascFactorial n (k + 1)
Theorem: differentiableAt_iff_restrictScalars
File: Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean

tactic: rw [← differentiableWithinAt_univ, ← fderivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
𝕜' : Type u_4
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NormedAlgebra 𝕜 𝕜'
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜' E
inst✝⁴ : IsScalarTower 𝕜 𝕜' E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
f : E → F
f' : E →L[𝕜'] F
s : Set E
x : E
hf : DifferentiableAt 𝕜 f x
⊢ DifferentiableAt 𝕜' f x ↔ ∃ g', restrictScalars 𝕜 g' = fderiv 𝕜 f x

tactic: exact
  differentiableWithinAt_iff_restrictScalars 𝕜 hf.differentiableWithinAt uniqueDiffWithinAt_univ
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
𝕜' : Type u_4
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NormedAlgebra 𝕜 𝕜'
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜' E
inst✝⁴ : IsScalarTower 𝕜 𝕜' E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
f : E → F
f' : E →L[𝕜'] F
s : Set E
x : E
hf : DifferentiableAt 𝕜 f x
⊢ DifferentiableWithinAt 𝕜' f univ x ↔ ∃ g', restrictScalars 𝕜 g' = fderivWithin 𝕜 f univ x
Theorem: MeasureTheory.integrableOn_Ioi_deriv_of_nonpos'
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: refine integrableOn_Ioi_deriv_of_nonpos (fun x hx ↦ ?_) (fun x hx ↦ hderiv x hx.out.le) g'neg hg
state_before: E : Type ?u.164089
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt g (g' x) x
g'neg : ∀ (x : ℝ), x ∈ Ioi a → g' x ≤ 0
hg : Tendsto g atTop (𝓝 l)
⊢ IntegrableOn g' (Ioi a)

tactic: exact (hderiv x hx).continuousAt.continuousWithinAt
state_before: E : Type ?u.164089
f f' : ℝ → E
g g' : ℝ → ℝ
a b l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hderiv : ∀ (x : ℝ), x ∈ Ici a → HasDerivAt g (g' x) x
g'neg : ∀ (x : ℝ), x ∈ Ioi a → g' x ≤ 0
hg : Tendsto g atTop (𝓝 l)
x : ℝ
hx : x ∈ Ici a
⊢ ContinuousWithinAt g (Ici a) x
Theorem: SimpleGraph.ComponentCompl.hom_refl
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: change C.map _ = C
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
⊢ hom (_ : L ⊆ L) C = C

tactic: erw [induceHom_id G (Lᶜ), ConnectedComponent.map_id]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
⊢ ConnectedComponent.map (InduceHom Hom.id (_ : Lᶜ ⊆ Lᶜ)) C = C
Theorem: multiplicity.pow_sub_pow_of_prime
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: rw [← geom_sum₂_mul, multiplicity.mul hp, multiplicity_eq_zero.2 (not_dvd_geom_sum₂ hp hxy hx hn),
  zero_add]
state_before: R : Type u_1
n✝ : ℕ
inst✝² : CommRing R
a b x✝ y✝ : R
p✝ : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : R
hp : Prime p
x y : R
hxy : p ∣ x - y
hx : ¬p ∣ x
n : ℕ
hn : ¬p ∣ ↑n
⊢ multiplicity p (x ^ n - y ^ n) = multiplicity p (x - y)
Theorem: continuous_iInf_rng
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_coinduced_le, le_iInf_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.42166
f : α → β
ι : Sort u_1
t₁ : TopologicalSpace α
t₂ : ι → TopologicalSpace β
⊢ Continuous f ↔ ∀ (i : ι), Continuous f
Theorem: Int.neg_le_sub_left_of_le_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.le_neg_add_of_add_le (Int.sub_left_le_of_le_add h)
state_before: a b c : Int
h : c ≤ a + b
⊢ -a ≤ b - c

tactic: rwa [Int.add_comm] at h
state_before: a b c : Int
h✝ : c ≤ a + b
h : -a ≤ -c + b
⊢ -a ≤ b - c
Theorem: Cardinal.mk_sUnion_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [sUnion_eq_iUnion]
state_before: α✝ β α : Type u
A : Set (Set α)
⊢ (#↑(⋃₀ A)) ≤ (#↑A) * ⨆ (s : ↑A), #↑↑s

tactic: apply mk_iUnion_le
state_before: α✝ β α : Type u
A : Set (Set α)
⊢ (#↑(⋃ (i : ↑A), ↑i)) ≤ (#↑A) * ⨆ (s : ↑A), #↑↑s
Theorem: Seminorm.preimage_metric_closedBall
File: Mathlib/Analysis/Seminorm.lean

tactic: ext x
state_before: R : Type ?u.1012446
R' : Type ?u.1012449
𝕜 : Type u_2
𝕜₂ : Type ?u.1012455
𝕜₃ : Type ?u.1012458
𝕝 : Type ?u.1012461
E : Type u_1
E₂ : Type ?u.1012467
E₃ : Type ?u.1012470
F : Type ?u.1012473
G : Type ?u.1012476
ι : Type ?u.1012479
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
⊢ ↑p ⁻¹' Metric.closedBall 0 r = {x | ↑p x ≤ r}

tactic: simp only [mem_setOf, mem_preimage, mem_closedBall_zero_iff,
  Real.norm_of_nonneg (map_nonneg p _)]
state_before: case h
R : Type ?u.1012446
R' : Type ?u.1012449
𝕜 : Type u_2
𝕜₂ : Type ?u.1012455
𝕜₃ : Type ?u.1012458
𝕝 : Type ?u.1012461
E : Type u_1
E₂ : Type ?u.1012467
E₃ : Type ?u.1012470
F : Type ?u.1012473
G : Type ?u.1012476
ι : Type ?u.1012479
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
x : E
⊢ x ∈ ↑p ⁻¹' Metric.closedBall 0 r ↔ x ∈ {x | ↑p x ≤ r}
Theorem: List.mem_sections
File: Mathlib/Data/List/Sections.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.11
L : List (List α)
f : List α
⊢ f ∈ sections L ↔ Forall₂ (fun x x_1 => x ∈ x_1) f L

tactic: induction L generalizing f
state_before: case refine'_1
α : Type u_1
β : Type ?u.11
L : List (List α)
f : List α
h : f ∈ sections L
⊢ Forall₂ (fun x x_1 => x ∈ x_1) f L

tactic: simp only [sections, bind_eq_bind, mem_bind, mem_map] at h
state_before: case refine'_1.cons
α : Type u_1
β : Type ?u.11
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ {f : List α}, f ∈ sections tail✝ → Forall₂ (fun x x_1 => x ∈ x_1) f tail✝
f : List α
h : f ∈ sections (head✝ :: tail✝)
⊢ Forall₂ (fun x x_1 => x ∈ x_1) f (head✝ :: tail✝)

tactic: rcases h with ⟨_, _, _, _, rfl⟩
state_before: case refine'_1.cons
α : Type u_1
β : Type ?u.11
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ {f : List α}, f ∈ sections tail✝ → Forall₂ (fun x x_1 => x ∈ x_1) f tail✝
f : List α
h : ∃ a, a ∈ sections tail✝ ∧ ∃ a_1, a_1 ∈ head✝ ∧ a_1 :: a = f
⊢ Forall₂ (fun x x_1 => x ∈ x_1) f (head✝ :: tail✝)

tactic: simp only [*, forall₂_cons, true_and_iff]
state_before: case refine'_1.cons.intro.intro.intro.intro
α : Type u_1
β : Type ?u.11
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ {f : List α}, f ∈ sections tail✝ → Forall₂ (fun x x_1 => x ∈ x_1) f tail✝
w✝¹ : List α
left✝¹ : w✝¹ ∈ sections tail✝
w✝ : α
left✝ : w✝ ∈ head✝
⊢ Forall₂ (fun x x_1 => x ∈ x_1) (w✝ :: w✝¹) (head✝ :: tail✝)

tactic: cases mem_singleton.1 h
state_before: case refine'_1.nil
α : Type u_1
β : Type ?u.11
f : List α
h : f ∈ sections []
⊢ Forall₂ (fun x x_1 => x ∈ x_1) f []

tactic: exact Forall₂.nil
state_before: case refine'_1.nil.refl
α : Type u_1
β : Type ?u.11
h : [] ∈ sections []
⊢ Forall₂ (fun x x_1 => x ∈ x_1) [] []

tactic: induction' h with a l f L al fL fs
state_before: case refine'_2
α : Type u_1
β : Type ?u.11
L : List (List α)
f : List α
h : Forall₂ (fun x x_1 => x ∈ x_1) f L
⊢ f ∈ sections L

tactic: simp only [sections, bind_eq_bind, mem_bind, mem_map]
state_before: case refine'_2.cons
α : Type u_1
β : Type ?u.11
L✝ : List (List α)
f✝ : List α
a : α
l f : List α
L : List (List α)
al : a ∈ l
fL : Forall₂ (fun x x_1 => x ∈ x_1) f L
fs : f ∈ sections L
⊢ a :: f ∈ sections (l :: L)

tactic: exact ⟨f, fs, a, al, rfl⟩
state_before: case refine'_2.cons
α : Type u_1
β : Type ?u.11
L✝ : List (List α)
f✝ : List α
a : α
l f : List α
L : List (List α)
al : a ∈ l
fL : Forall₂ (fun x x_1 => x ∈ x_1) f L
fs : f ∈ sections L
⊢ ∃ a_1, a_1 ∈ sections L ∧ ∃ a_2, a_2 ∈ l ∧ a_2 :: a_1 = a :: f

tactic: simp only [sections, mem_singleton]
state_before: case refine'_2.nil
α : Type u_1
β : Type ?u.11
L : List (List α)
f : List α
⊢ [] ∈ sections []
Theorem: Polynomial.mem_roots'
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [← count_pos, count_roots p, rootMultiplicity_pos']
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ a ∈ roots p ↔ p ≠ 0 ∧ IsRoot p a
Theorem: FirstOrder.Language.Theory.exists_modelType_is_realized_in
File: Mathlib/ModelTheory/Types.lean

tactic: obtain ⟨M⟩ := p.isMaximal.1
state_before: L : Language
T : Theory L
α : Type w
M : Type w'
inst✝² : Structure L M
inst✝¹ : Nonempty M
inst✝ : M ⊨ T
p : CompleteType T α
⊢ ∃ M, p ∈ realizedTypes T (↑M) α

tactic: refine' ⟨(M.subtheoryModel p.subset).reduct (L.lhomWithConstants α), fun a => (L.con a : M), _⟩
state_before: case intro
L : Language
T : Theory L
α : Type w
M✝ : Type w'
inst✝² : Structure L M✝
inst✝¹ : Nonempty M✝
inst✝ : M✝ ⊨ T
p : CompleteType T α
M : ModelType ↑p
⊢ ∃ M, p ∈ realizedTypes T (↑M) α

tactic: refine' SetLike.ext fun φ => _
state_before: case intro
L : Language
T : Theory L
α : Type w
M✝ : Type w'
inst✝² : Structure L M✝
inst✝¹ : Nonempty M✝
inst✝ : M✝ ⊨ T
p : CompleteType T α
M : ModelType ↑p
⊢ (typeOf T fun a => ↑(Language.con L a)) = p

tactic: simp only [CompleteType.mem_typeOf]
state_before: case intro
L : Language
T : Theory L
α : Type w
M✝ : Type w'
inst✝² : Structure L M✝
inst✝¹ : Nonempty M✝
inst✝ : M✝ ⊨ T
p : CompleteType T α
M : ModelType ↑p
φ : Sentence (L[[α]])
⊢ (φ ∈ typeOf T fun a => ↑(Language.con L a)) ↔ φ ∈ p

tactic: refine'
  (@Formula.realize_equivSentence_symm_con _
    ((M.subtheoryModel p.subset).reduct (L.lhomWithConstants α)) _ _ M.struc _ φ).trans
    (_root_.trans (_root_.trans _ (p.isMaximal.isComplete.realize_sentence_iff φ M))
      (p.isMaximal.mem_iff_models φ).symm)
state_before: case intro
L : Language
T : Theory L
α : Type w
M✝ : Type w'
inst✝² : Structure L M✝
inst✝¹ : Nonempty M✝
inst✝ : M✝ ⊨ T
p : CompleteType T α
M : ModelType ↑p
φ : Sentence (L[[α]])
⊢ (Formula.Realize (↑Formula.equivSentence.symm φ) fun a => ↑(Language.con L a)) ↔ φ ∈ p

tactic: rfl
state_before: case intro
L : Language
T : Theory L
α : Type w
M✝ : Type w'
inst✝² : Structure L M✝
inst✝¹ : Nonempty M✝
inst✝ : M✝ ⊨ T
p : CompleteType T α
M : ModelType ↑p
φ : Sentence (L[[α]])
⊢ ↑(ModelType.reduct (lhomWithConstants L α)
          (ModelType.subtheoryModel M (_ : LHom.onTheory (lhomWithConstants L α) T ⊆ ↑p))) ⊨
      φ ↔
    ↑M ⊨ φ
Theorem: List.mem_pmap
File: Mathlib/Data/List/Basic.lean

tactic: simp only [pmap_eq_map_attach, mem_map, mem_attach, true_and_iff, Subtype.exists, eq_comm]
state_before: ι : Type ?u.328936
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
H : ∀ (a : α), a ∈ l → p a
b : β
⊢ b ∈ pmap f l H ↔ ∃ a h, f a (_ : p a) = b
Theorem: Pmf.ofMultiset_apply_of_not_mem
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simpa only [ofMultiset_apply, ENNReal.div_eq_zero_iff, Nat.cast_eq_zero, Multiset.count_eq_zero,
  ENNReal.nat_ne_top, or_false_iff] using ha
state_before: α : Type u_1
β : Type ?u.183679
γ : Type ?u.183682
s : Multiset α
hs : s ≠ 0
a : α
ha : ¬a ∈ s
⊢ ↑(ofMultiset s hs) a = 0
Theorem: Heyting.IsRegular.himp
File: Mathlib/Order/Heyting/Regular.lean

tactic: rw [IsRegular, compl_compl_himp_distrib, ha.eq, hb.eq]
state_before: α : Type u_1
inst✝ : HeytingAlgebra α
a b : α
ha : IsRegular a
hb : IsRegular b
⊢ IsRegular (a ⇨ b)
Theorem: Finset.map_add_right_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Ico, coe_Ico]
state_before: ι : Type ?u.218659
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Ico a b) = Ico (a + c) (b + c)

tactic: exact Set.image_add_const_Ico _ _ _
state_before: ι : Type ?u.218659
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addRightEmbedding c) '' Set.Ico a b = Set.Ico (a + c) (b + c)
Theorem: Polynomial.Separable.isCoprime
File: Mathlib/FieldTheory/Separable.lean

tactic: have := h.of_mul_left_left
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : Separable (f * g)
⊢ IsCoprime f g

tactic: rw [derivative_mul] at this
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : Separable (f * g)
this : IsCoprime f (↑derivative (f * g))
⊢ IsCoprime f g

tactic: exact IsCoprime.of_mul_right_right (IsCoprime.of_add_mul_left_right this)
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
h : Separable (f * g)
this : IsCoprime f (↑derivative f * g + f * ↑derivative g)
⊢ IsCoprime f g
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_sub_sub
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [sub_def, ← lift_sub_lift, sub_def, Category.assoc, σ_comp, prod.lift_map_assoc]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ a - c - (b - d) = a - b - (c - d)

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b ≫ σ) (prod.lift c d ≫ σ) ≫ σ = a - b - (c - d)
Theorem: Finset.not_mem_union
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [mem_union, not_or]
state_before: α : Type u_1
β : Type ?u.141391
γ : Type ?u.141394
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ ¬a ∈ s ∪ t ↔ ¬a ∈ s ∧ ¬a ∈ t
Theorem: Matrix.det_updateColumn_smul
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← det_transpose, ← updateRow_transpose, det_updateRow_smul]
state_before: m : Type ?u.1649973
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ det (updateColumn M j (s • u)) = s * det (updateColumn M j u)

tactic: simp [updateRow_transpose, det_transpose]
state_before: m : Type ?u.1649973
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s * det (updateRow Mᵀ j u) = s * det (updateColumn M j u)