tasksource/leandojo huggingface dataset:
Theorem: EMetric.mem_closure_iff_infEdist_zero
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [← infEdist_closure]
state_before: ι : Sort ?u.16967
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
h : x ∈ closure s
⊢ infEdist x s = 0

tactic: exact infEdist_zero_of_mem h
state_before: ι : Sort ?u.16967
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
h : x ∈ closure s
⊢ infEdist x (closure s) = 0

tactic: rwa [h]
state_before: ι : Sort ?u.16967
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
h : infEdist x s = 0
ε : ℝ≥0∞
εpos : ε > 0
⊢ infEdist x s < ε
Theorem: hasDerivAt_of_tendstoLocallyUniformlyOn
File: Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean

tactic: have h1 : s ∈ 𝓝 x := hs.mem_nhds hx
state_before: ι : Type u_1
l : Filter ι
𝕜 : Type u_2
inst✝³ : IsROrC 𝕜
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
inst✝ : NeBot l
s : Set 𝕜
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn f' g' l s
hf : ∀ᶠ (n : ι) in l, ∀ (x : 𝕜), x ∈ s → HasDerivAt (f n) (f' n x) x
hfg : ∀ (x : 𝕜), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
⊢ HasDerivAt g (g' x) x

tactic: have h2 : ∀ᶠ n : ι × 𝕜 in l ×ˢ 𝓝 x, HasDerivAt (f n.1) (f' n.1 n.2) n.2 :=
  eventually_prod_iff.2 ⟨_, hf, fun x => x ∈ s, h1, fun {n} => id⟩
state_before: ι : Type u_1
l : Filter ι
𝕜 : Type u_2
inst✝³ : IsROrC 𝕜
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
inst✝ : NeBot l
s : Set 𝕜
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn f' g' l s
hf : ∀ᶠ (n : ι) in l, ∀ (x : 𝕜), x ∈ s → HasDerivAt (f n) (f' n x) x
hfg : ∀ (x : 𝕜), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
h1 : s ∈ 𝓝 x
⊢ HasDerivAt g (g' x) x

tactic: refine' hasDerivAt_of_tendstoUniformlyOnFilter _ h2 (eventually_of_mem h1 hfg)
state_before: ι : Type u_1
l : Filter ι
𝕜 : Type u_2
inst✝³ : IsROrC 𝕜
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
inst✝ : NeBot l
s : Set 𝕜
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn f' g' l s
hf : ∀ᶠ (n : ι) in l, ∀ (x : 𝕜), x ∈ s → HasDerivAt (f n) (f' n x) x
hfg : ∀ (x : 𝕜), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
h1 : s ∈ 𝓝 x
h2 : ∀ᶠ (n : ι × 𝕜) in l ×ˢ 𝓝 x, HasDerivAt (f n.fst) (f' n.fst n.snd) n.snd
⊢ HasDerivAt g (g' x) x

tactic: simpa [IsOpen.nhdsWithin_eq hs hx] using tendstoLocallyUniformlyOn_iff_filter.mp hf' x hx
state_before: ι : Type u_1
l : Filter ι
𝕜 : Type u_2
inst✝³ : IsROrC 𝕜
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → 𝕜 → G
g : 𝕜 → G
f' : ι → 𝕜 → G
g' : 𝕜 → G
x : 𝕜
inst✝ : NeBot l
s : Set 𝕜
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn f' g' l s
hf : ∀ᶠ (n : ι) in l, ∀ (x : 𝕜), x ∈ s → HasDerivAt (f n) (f' n x) x
hfg : ∀ (x : 𝕜), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
h1 : s ∈ 𝓝 x
h2 : ∀ᶠ (n : ι × 𝕜) in l ×ˢ 𝓝 x, HasDerivAt (f n.fst) (f' n.fst n.snd) n.snd
⊢ TendstoUniformlyOnFilter f' g' l (𝓝 x)
Theorem: Matrix.mul_sub
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [sub_eq_add_neg, Matrix.mul_add, Matrix.mul_neg, sub_eq_add_neg]
state_before: l : Type ?u.383149
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.383163
n' : o → Type ?u.383168
R : Type ?u.383171
S : Type ?u.383174
α : Type v
β : Type w
γ : Type ?u.383181
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N N' : Matrix n o α
⊢ M ⬝ (N - N') = M ⬝ N - M ⬝ N'
Theorem: Nat.squarefree_iff_minSqFac
File: Mathlib/Data/Nat/Squarefree.lean

tactic: have := minSqFac_has_prop n
state_before: n : ℕ
⊢ Squarefree n ↔ minSqFac n = none

tactic: constructor <;> intro H
state_before: n : ℕ
this : MinSqFacProp n (minSqFac n)
⊢ Squarefree n ↔ minSqFac n = none

tactic: cases' e : n.minSqFac with d
state_before: case mp
n : ℕ
this : MinSqFacProp n (minSqFac n)
H : Squarefree n
⊢ minSqFac n = none

tactic: rw [e] at this
state_before: case mp.some
n : ℕ
this : MinSqFacProp n (minSqFac n)
H : Squarefree n
d : ℕ
e : minSqFac n = some d
⊢ some d = none

tactic: cases squarefree_iff_prime_squarefree.1 H _ this.1 this.2.1
state_before: case mp.some
n : ℕ
H : Squarefree n
d : ℕ
this : MinSqFacProp n (some d)
e : minSqFac n = some d
⊢ some d = none

tactic: rfl
state_before: case mp.none
n : ℕ
this : MinSqFacProp n (minSqFac n)
H : Squarefree n
e : minSqFac n = none
⊢ none = none

tactic: rwa [H] at this
state_before: case mpr
n : ℕ
this : MinSqFacProp n (minSqFac n)
H : minSqFac n = none
⊢ Squarefree n
Theorem: Fin.comp_tail
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
β : Type u_2
g : α → β
q : Fin (Nat.succ n) → α
⊢ g ∘ tail q = tail (g ∘ q)

tactic: simp [tail]
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
β : Type u_2
g : α → β
q : Fin (Nat.succ n) → α
j : Fin n
⊢ (g ∘ tail q) j = tail (g ∘ q) j
Theorem: Inducing.regularSpace
File: Mathlib/Topology/Separation.lean

tactic: rw [hf.nhds_eq_comap b]
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : RegularSpace α
a : α
s : Set α
inst✝ : TopologicalSpace β
f : β → α
hf : Inducing f
b : β
⊢ HasBasis (𝓝 b) (?m.154015 hf b) (?m.154016 hf b)

tactic: exact (closed_nhds_basis _).comap _
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : RegularSpace α
a : α
s : Set α
inst✝ : TopologicalSpace β
f : β → α
hf : Inducing f
b : β
⊢ HasBasis (comap f (𝓝 (f b))) (?m.154015 hf b) (?m.154016 hf b)

α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ [inst : TopologicalSpace β] → {f : β → α} → Inducing f → β → Sort ?u.153945

α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ [inst : TopologicalSpace β] → {f : β → α} → (hf : Inducing f) → (a : β) → ?m.154014 hf a → Prop

α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ [inst : TopologicalSpace β] → {f : β → α} → (hf : Inducing f) → (a : β) → ?m.154014 hf a → Set β

tactic: exact hs.2.preimage hf.continuous
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : RegularSpace α
a : α
s✝ : Set α
inst✝ : TopologicalSpace β
f : β → α
hf : Inducing f
b : β
s : Set α
hs : s ∈ 𝓝 (f b) ∧ IsClosed s
⊢ IsClosed (f ⁻¹' id s)
Theorem: isPreconnected_connectedComponentIn
File: Mathlib/Topology/Connected.lean

tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type ?u.53054
π : ι → Type ?u.53059
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsPreconnected (connectedComponentIn F x)

tactic: split_ifs
state_before: α : Type u
β : Type v
ι : Type ?u.53054
π : ι → Type ?u.53059
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsPreconnected (if h : x ∈ F then Subtype.val '' connectedComponent { val := x, property := h } else ∅)

tactic: exact inducing_subtype_val.isPreconnected_image.mpr isPreconnected_connectedComponent
state_before: case inl
α : Type u
β : Type v
ι : Type ?u.53054
π : ι → Type ?u.53059
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
h✝ : x ∈ F
⊢ IsPreconnected (Subtype.val '' connectedComponent { val := x, property := h✝ })

tactic: exact isPreconnected_empty
state_before: case inr
α : Type u
β : Type v
ι : Type ?u.53054
π : ι → Type ?u.53059
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
h✝ : ¬x ∈ F
⊢ IsPreconnected ∅
Theorem: Algebra.TensorProduct.basis_repr_symm_apply
File: Mathlib/RingTheory/TensorProduct.lean

tactic: rw [basis, LinearEquiv.coe_symm_mk]
state_before: k : Type u_4
inst✝⁴ : CommRing k
R : Type u_1
inst✝³ : Ring R
inst✝² : Algebra k R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module k M
ι : Type u_3
b : Basis ι k M
r : R
i : ι
⊢ ↑(LinearEquiv.symm (basis R b).repr) (Finsupp.single i r) = r ⊗ₜ[k] ↑(LinearEquiv.symm b.repr) (Finsupp.single i 1)

tactic: simp [Equiv.uniqueProd_symm_apply, basisAux]
state_before: k : Type u_4
inst✝⁴ : CommRing k
R : Type u_1
inst✝³ : Ring R
inst✝² : Algebra k R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module k M
ι : Type u_3
b : Basis ι k M
r : R
i : ι
⊢ LinearEquiv.invFun (basisAux R b) (Finsupp.single i r) = r ⊗ₜ[k] ↑(LinearEquiv.symm b.repr) (Finsupp.single i 1)
Theorem: Quotient.finChoiceAux_eq
File: Mathlib/Data/Fintype/Quotient.lean

tactic: simp [Quotient.finChoiceAux, Quotient.finChoiceAux_eq l, -Quotient.eq]
state_before: ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
⊢ (finChoiceAux (i :: l) fun i_1 h => Quotient.mk (S i_1) (f i_1 h)) = Quotient.mk inferInstance f

tactic: refine' Quotient.sound fun j h => _
state_before: ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
⊢ (Quotient.mk inferInstance fun j h =>
      if h : j = i then cast (_ : (fun i => α i) i = (fun i => α i) j) (f i (_ : i ∈ i :: l))
      else f j (_ : j ∈ i :: l)) =
    Quotient.mk inferInstance f

tactic: by_cases e : j = i <;> simp [e] <;> try exact Setoid.refl _
state_before: ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
j : ι
h : j ∈ i :: l
⊢ (if h : j = i then cast (_ : (fun i => α i) i = (fun i => α i) j) (f i (_ : i ∈ i :: l)) else f j (_ : j ∈ i :: l)) ≈
    f j h

tactic: subst j
state_before: case pos
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
j : ι
h : j ∈ i :: l
e : j = i
⊢ cast (_ : (fun i => α i) i = (fun i => α i) j) (f i (_ : i ∈ i :: l)) ≈ f j h

tactic: exact Setoid.refl _
state_before: case pos
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
h : i ∈ i :: l
⊢ cast (_ : (fun i => α i) i = (fun i => α i) i) (f i (_ : i ∈ i :: l)) ≈ f i h

tactic: exact Setoid.refl _
state_before: case neg
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
S : (i : ι) → Setoid (α i)
i : ι
l : List ι
f : (i_1 : ι) → i_1 ∈ i :: l → α i_1
j : ι
h : j ∈ i :: l
e : ¬j = i
⊢ f j (_ : j ∈ i :: l) ≈ f j h
Theorem: MeasureTheory.withDensity_indicator_one
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [withDensity_indicator hs, withDensity_one]
state_before: α : Type u_1
β : Type ?u.1769295
γ : Type ?u.1769298
δ : Type ?u.1769301
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hs : MeasurableSet s
⊢ withDensity μ (indicator s 1) = Measure.restrict μ s
Theorem: SimpleGraph.compl_neighborFinset_sdiff_inter_eq
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: ext
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
⊢ neighborFinset G vᶜ \ {v} ∩ (neighborFinset G wᶜ \ {w}) = (neighborFinset G vᶜ ∩ neighborFinset G wᶜ) \ ({w} ∪ {v})

tactic: rw [← not_iff_not]
state_before: case a
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w a✝ : V
⊢ a✝ ∈ neighborFinset G vᶜ \ {v} ∩ (neighborFinset G wᶜ \ {w}) ↔
    a✝ ∈ (neighborFinset G vᶜ ∩ neighborFinset G wᶜ) \ ({w} ∪ {v})

tactic: simp [imp_iff_not_or, or_assoc, or_comm, or_left_comm]
state_before: case a
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w a✝ : V
⊢ ¬a✝ ∈ neighborFinset G vᶜ \ {v} ∩ (neighborFinset G wᶜ \ {w}) ↔
    ¬a✝ ∈ (neighborFinset G vᶜ ∩ neighborFinset G wᶜ) \ ({w} ∪ {v})
Theorem: Equiv.mul_swap_mul_self
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: rw [mul_assoc, swap_mul_self, mul_one]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ σ * swap i j * swap i j = σ
Theorem: Finset.prod_unique_nonempty
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [h.eq_singleton_default, Finset.prod_singleton]
state_before: ι : Type ?u.876223
β✝ : Type u
α✝ : Type v
γ : Type w
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝¹ : CommMonoid β
inst✝ : Unique α
s : Finset α
f : α → β
h : Finset.Nonempty s
⊢ ∏ x in s, f x = f default
Theorem: MeasureTheory.mem_ae_dirac_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases a ∈ s <;> simp [mem_ae_iff, dirac_apply', hs.compl, indicator_apply, *]
state_before: α : Type u_1
β : Type ?u.599009
γ : Type ?u.599012
δ : Type ?u.599015
ι : Type ?u.599018
R : Type ?u.599021
R' : Type ?u.599024
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
a : α
hs : MeasurableSet s
⊢ s ∈ ae (dirac a) ↔ a ∈ s
Theorem: Filter.tendsto_nhds_max_left
File: Mathlib/Topology/Order/Basic.lean

tactic: simp_rw [max_comm _ a]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝[Ioi a] a)
⊢ Tendsto (fun i => max (f i) a) l (𝓝[Ioi a] a)

tactic: exact Filter.tendsto_nhds_max_right h
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderClosedTopology α
f g : β → α
l : Filter β
a : α
h : Tendsto f l (𝓝[Ioi a] a)
⊢ Tendsto (fun i => max a (f i)) l (𝓝[Ioi a] a)
Theorem: affineIndependent_equiv
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: refine' ⟨_, AffineIndependent.comp_embedding e.toEmbedding⟩
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
⊢ AffineIndependent k (p ∘ ↑e) ↔ AffineIndependent k p

tactic: intro h
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
⊢ AffineIndependent k (p ∘ ↑e) → AffineIndependent k p

tactic: have : p = p ∘ e ∘ e.symm.toEmbedding := by
  ext
  simp
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ↑e)
⊢ AffineIndependent k p

tactic: rw [this]
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ↑e)
this : p = p ∘ ↑e ∘ ↑(Equiv.toEmbedding e.symm)
⊢ AffineIndependent k p

tactic: exact h.comp_embedding e.symm.toEmbedding
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ↑e)
this : p = p ∘ ↑e ∘ ↑(Equiv.toEmbedding e.symm)
⊢ AffineIndependent k (p ∘ ↑e ∘ ↑(Equiv.toEmbedding e.symm))

tactic: ext
state_before: k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ↑e)
⊢ p = p ∘ ↑e ∘ ↑(Equiv.toEmbedding e.symm)

tactic: simp
state_before: case h
k : Type u_3
V : Type u_4
P : Type u_5
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_2
ι' : Type u_1
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ↑e)
x✝ : ι'
⊢ p x✝ = (p ∘ ↑e ∘ ↑(Equiv.toEmbedding e.symm)) x✝
Theorem: Order.pred_lt_pred_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred a < pred b ↔ a < b
Theorem: Dfinsupp.add_eq_zero_iff
File: Mathlib/Data/Dfinsupp/Order.lean

tactic: simp [FunLike.ext_iff, forall_and]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → CanonicallyOrderedAddMonoid (α i)
f g : Π₀ (i : ι), α i
⊢ f + g = 0 ↔ f = 0 ∧ g = 0
Theorem: Real.tendsto_sum_range_one_div_nat_succ_atTop
File: Mathlib/Analysis/PSeries.lean

tactic: rw [← not_summable_iff_tendsto_nat_atTop_of_nonneg]
state_before: ⊢ Tendsto (fun n => ∑ i in Finset.range n, 1 / (↑i + 1)) atTop atTop

tactic: exact_mod_cast mt (_root_.summable_nat_add_iff 1).1 Real.not_summable_one_div_nat_cast
state_before: ⊢ ¬Summable fun i => 1 / (↑i + 1)

tactic: exact fun i => div_nonneg zero_le_one i.cast_add_one_pos.le
state_before: ⊢ ∀ (n : ℕ), 0 ≤ 1 / (↑n + 1)
Theorem: Equiv.Perm.support_swap_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine' ⟨fun h => _, fun h => support_swap h⟩
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
⊢ support (swap x y) = {x, y} ↔ x ≠ y

tactic: by_contra'
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : support (swap x y) = {x, y}
⊢ x ≠ y

tactic: rw [← this] at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : support (swap x y) = {x, y}
this : x = y
⊢ False

tactic: simp only [swap_self, support_refl, pair_eq_singleton] at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : support (swap x x) = {x, x}
this : x = y
⊢ False

tactic: have : x ∈ ∅ := by
  rw [h]
  exact mem_singleton.mpr rfl
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this : x = y
h : ∅ = {x}
⊢ False

tactic: have := (Finset.ne_empty_of_mem this)
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this✝ : x = y
h : ∅ = {x}
this : x ∈ ∅
⊢ False

tactic: exact this rfl
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this✝¹ : x = y
h : ∅ = {x}
this✝ : x ∈ ∅
this : ∅ ≠ ∅
⊢ False

tactic: rw [h]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this : x = y
h : ∅ = {x}
⊢ x ∈ ∅

tactic: exact mem_singleton.mpr rfl
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this : x = y
h : ∅ = {x}
⊢ x ∈ {x}

α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
this : x = y
h : ∅ = {x}
⊢ Membership α (Finset α)
Theorem: Nat.totient_one
File: Mathlib/Data/Nat/Totient.lean

tactic: simp [totient]
state_before: ⊢ φ 1 = 1
Theorem: PNat.Prime.ne_one
File: Mathlib/Data/PNat/Prime.lean

tactic: intro pp
state_before: p : ℕ+
⊢ Prime p → p ≠ 1

tactic: intro contra
state_before: p : ℕ+
pp : Prime p
⊢ p ≠ 1

tactic: apply Nat.Prime.ne_one pp
state_before: p : ℕ+
pp : Prime p
contra : p = 1
⊢ False

tactic: rw [PNat.coe_eq_one_iff]
state_before: p : ℕ+
pp : Prime p
contra : p = 1
⊢ ↑p = 1

tactic: apply contra
state_before: p : ℕ+
pp : Prime p
contra : p = 1
⊢ p = 1
Theorem: List.map_eq_nil
File: Std/Data/List/Lemmas.lean

tactic: constructor <;> exact fun _ => match l with | [] => rfl
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
⊢ map f l = [] ↔ l = []
Theorem: Int.abs_lt_one_iff
File: Mathlib/Data/Int/Order/Basic.lean

tactic: let ⟨hn, hp⟩ := abs_lt.mp a0
state_before: a : ℤ
a0 : abs a < 1
⊢ a = 0

tactic: rw [←zero_add 1, lt_add_one_iff] at hp
state_before: a : ℤ
a0 : abs a < 1
hn : -1 < a
hp : a < 1
⊢ a = 0

tactic: exact hp.antisymm hn
state_before: a : ℤ
a0 : abs a < 1
hn : -1 < a
hp✝ : a < 1
hp : a ≤ 0
⊢ a = 0
Theorem: hasSum_nat_add_iff'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp [hasSum_nat_add_iff]
state_before: α : Type u_1
β : Type ?u.453865
γ : Type ?u.453868
δ : Type ?u.453871
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
f : ℕ → α
k : ℕ
a : α
⊢ HasSum (fun n => f (n + k)) (a - ∑ i in range k, f i) ↔ HasSum f a
Theorem: Finmap.liftOn₂_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: cases s₁
state_before: α : Type u
β : α → Type v
γ : Type u_1
s₁ s₂ : AList β
f : AList β → AList β → γ
H : ∀ (a₁ b₁ a₂ b₂ : AList β), a₁.entries ~ a₂.entries → b₁.entries ~ b₂.entries → f a₁ b₁ = f a₂ b₂
⊢ liftOn₂ ⟦s₁⟧ ⟦s₂⟧ f H = f s₁ s₂

tactic: cases s₂
state_before: case mk
α : Type u
β : α → Type v
γ : Type u_1
s₂ : AList β
f : AList β → AList β → γ
H : ∀ (a₁ b₁ a₂ b₂ : AList β), a₁.entries ~ a₂.entries → b₁.entries ~ b₂.entries → f a₁ b₁ = f a₂ b₂
entries✝ : List (Sigma β)
nodupKeys✝ : NodupKeys entries✝
⊢ liftOn₂ ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧ ⟦s₂⟧ f H =
    f { entries := entries✝, nodupKeys := nodupKeys✝ } s₂

tactic: rfl
state_before: case mk.mk
α : Type u
β : α → Type v
γ : Type u_1
f : AList β → AList β → γ
H : ∀ (a₁ b₁ a₂ b₂ : AList β), a₁.entries ~ a₂.entries → b₁.entries ~ b₂.entries → f a₁ b₁ = f a₂ b₂
entries✝¹ : List (Sigma β)
nodupKeys✝¹ : NodupKeys entries✝¹
entries✝ : List (Sigma β)
nodupKeys✝ : NodupKeys entries✝
⊢ liftOn₂ ⟦{ entries := entries✝¹, nodupKeys := nodupKeys✝¹ }⟧ ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧ f H =
    f { entries := entries✝¹, nodupKeys := nodupKeys✝¹ } { entries := entries✝, nodupKeys := nodupKeys✝ }
Theorem: Set.sUnion_eq_univ_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [eq_univ_iff_forall, mem_sUnion]
state_before: α : Type u_1
β : Type ?u.128718
γ : Type ?u.128721
ι : Sort ?u.128724
ι' : Sort ?u.128727
ι₂ : Sort ?u.128730
κ : ι → Sort ?u.128735
κ₁ : ι → Sort ?u.128740
κ₂ : ι → Sort ?u.128745
κ' : ι' → Sort ?u.128750
c : Set (Set α)
⊢ ⋃₀ c = univ ↔ ∀ (a : α), ∃ b, b ∈ c ∧ a ∈ b
Theorem: List.tendsto_cons
File: Mathlib/Topology/List.lean

tactic: rw [nhds_cons, Tendsto, Filter.map_prod]
state_before: α : Type u_1
β : Type ?u.4553
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
l : List α
⊢ Tendsto (fun p => p.fst :: p.snd) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: l))

tactic: exact le_rfl
state_before: α : Type u_1
β : Type ?u.4553
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
l : List α
⊢ Filter.seq (Filter.map (fun a b => (a, b).fst :: (a, b).snd) (𝓝 a)) (𝓝 l) ≤ Seq.seq (cons <$> 𝓝 a) fun x => 𝓝 l
Theorem: summable_mul_right_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only [mul_inv_cancel_right₀ h] using H.mul_right a⁻¹
state_before: ι : Type u_2
κ : Type ?u.14348
R : Type ?u.14351
α : Type u_1
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a ≠ 0
H : Summable fun i => f i * a
⊢ Summable f
Theorem: Cardinal.lift_two_power
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp [←one_add_one_eq_two]
state_before: α β : Type u
a : Cardinal
⊢ lift (2 ^ a) = 2 ^ lift a
Theorem: Int.eq_neg_of_eq_neg
File: Std/Data/Int/Lemmas.lean

tactic: rw [h, Int.neg_neg]
state_before: a b : Int
h : a = -b
⊢ b = -a
Theorem: AList.insert_lookupFinsupp
File: Mathlib/Data/Finsupp/AList.lean

tactic: ext b
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
⊢ lookupFinsupp (insert a m l) = Finsupp.update (lookupFinsupp l) a m

tactic: by_cases h : b = a <;> simp [h]
state_before: case h
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
b : α
⊢ ↑(lookupFinsupp (insert a m l)) b = ↑(Finsupp.update (lookupFinsupp l) a m) b
Theorem: round_add_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [round, round, Int.fract_add_int, Int.floor_add_int, Int.ceil_add_int, ← apply_ite₂, ite_self]
state_before: F : Type ?u.254324
α : Type u_1
β : Type ?u.254330
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
y : ℤ
⊢ round (x + ↑y) = round x + y