tasksource/leandojo huggingface dataset:
Theorem: Homotopy.nullHomotopicMap'_f_of_not_rel_right
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: simp only [nullHomotopicMap']
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ Hom.f (nullHomotopicMap' h) k₁ = d C k₁ k₀ ≫ h k₀ k₁ r₁₀

tactic: rw [nullHomotopicMap_f_of_not_rel_right r₁₀ hk₁]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ Hom.f (nullHomotopicMap fun i j => dite (ComplexShape.Rel c j i) (h i j) fun x => 0) k₁ = d C k₁ k₀ ≫ h k₀ k₁ r₁₀

tactic: dsimp
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ (d C k₁ k₀ ≫ dite (ComplexShape.Rel c k₁ k₀) (h k₀ k₁) fun x => 0) = d C k₁ k₀ ≫ h k₀ k₁ r₁₀

tactic: split_ifs
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ (d C k₁ k₀ ≫ dite (ComplexShape.Rel c k₁ k₀) (h k₀ k₁) fun x => 0) = d C k₁ k₀ ≫ h k₀ k₁ r₁₀

tactic: rfl
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ d C k₁ k₀ ≫ h k₀ k₁ r₁₀ = d C k₁ k₀ ≫ h k₀ k₁ r₁₀
Theorem: Polynomial.not_mem_support_iff
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ¬n ∈ support p ↔ coeff p n = 0
Theorem: Rat.normalize.reduced
File: Std/Data/Rat/Basic.lean

tactic: match num, num.eq_nat_or_neg with
| _, ⟨_, .inl rfl⟩ => rfl
| _, ⟨_, .inr rfl⟩ => rw [Int.neg_div, Int.natAbs_neg, Int.natAbs_neg]; rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
e : g = Nat.gcd (Int.natAbs num) den
⊢ Int.natAbs (Int.div num ↑g) = Int.natAbs num / g

tactic: rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = Nat.gcd (Int.natAbs ↑w✝) den
⊢ Int.natAbs (Int.div ↑w✝ ↑g) = Int.natAbs ↑w✝ / g

tactic: rw [Int.neg_div, Int.natAbs_neg, Int.natAbs_neg]
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = Nat.gcd (Int.natAbs (-↑w✝)) den
⊢ Int.natAbs (Int.div (-↑w✝) ↑g) = Int.natAbs (-↑w✝) / g

tactic: rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = Nat.gcd (Int.natAbs (-↑w✝)) den
⊢ Int.natAbs (Int.div ↑w✝ ↑g) = Int.natAbs ↑w✝ / g
Theorem: LinearMap.fst_eq_coprod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext
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.82636
M₆ : Type ?u.82639
S : Type ?u.82642
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
⊢ fst R M M₂ = coprod id 0

tactic: simp
state_before: case h
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.82636
M₆ : Type ?u.82639
S : Type ?u.82642
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
x✝ : M × M₂
⊢ ↑(fst R M M₂) x✝ = ↑(coprod id 0) x✝
Theorem: Filter.le_countableGenerate_iff_of_countableInterFilter
File: Mathlib/Order/Filter/CountableInter.lean

tactic: constructor <;> intro h
state_before: ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
⊢ f ≤ countableGenerate g ↔ g ⊆ f.sets

tactic: intro s hs
state_before: case mpr
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
⊢ f ≤ countableGenerate g

tactic: induction' hs with s hs s t _ st ih S Sct _ ih
state_before: case mpr
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
hs : s ∈ countableGenerate g
⊢ s ∈ f

tactic: exact (countable_sInter_mem Sct).mpr ih
state_before: case mpr.sInter
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
S : Set (Set α)
Sct : Set.Countable S
a✝ : ∀ (s : Set α), s ∈ S → CountableGenerateSets g s
ih : ∀ (s : Set α), s ∈ S → s ∈ f
⊢ ⋂₀ S ∈ f

tactic: exact subset_trans (fun s => CountableGenerateSets.basic) h
state_before: case mp
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : f ≤ countableGenerate g
⊢ g ⊆ f.sets

tactic: exact h hs
state_before: case mpr.basic
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s✝ s : Set α
hs : s ∈ g
⊢ s ∈ f

tactic: exact univ_mem
state_before: case mpr.univ
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s : Set α
⊢ univ ∈ f

tactic: exact mem_of_superset ih st
state_before: case mpr.superset
ι : Sort ?u.24349
α : Type u_1
β : Type ?u.24355
l : Filter α
inst✝¹ : CountableInterFilter l
g : Set (Set α)
f : Filter α
inst✝ : CountableInterFilter f
h : g ⊆ f.sets
s✝ s t : Set α
a✝ : CountableGenerateSets g s
st : s ⊆ t
ih : s ∈ f
⊢ t ∈ f
Theorem: Polynomial.leadingCoeff_X_pow_sub_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C r, leadingCoeff_X_pow_add_C hn]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Ring R
n : ℕ
hn : 0 < n
r : R
⊢ leadingCoeff (X ^ n - ↑C r) = 1
Theorem: disjointed_eq_inf_compl
File: Mathlib/Order/Disjointed.lean

tactic: cases n
state_before: α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n : ℕ
⊢ disjointed f n = f n ⊓ ⨅ (i : ℕ) (_ : i < n), f iᶜ

tactic: simp_rw [disjointed_succ, partialSups_eq_biSup, sdiff_eq, compl_iSup]
state_before: case succ
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ disjointed f (Nat.succ n✝) = f (Nat.succ n✝) ⊓ ⨅ (i : ℕ) (_ : i < Nat.succ n✝), f iᶜ

tactic: congr
state_before: case succ
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ (f (n✝ + 1) ⊓ ⨅ (i : ℕ) (_ : i ≤ n✝), f iᶜ) = f (Nat.succ n✝) ⊓ ⨅ (i : ℕ) (_ : i < Nat.succ n✝), f iᶜ

tactic: ext i
state_before: case succ.e_a.e_s
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ (fun i => ⨅ (_ : i ≤ n✝), f iᶜ) = fun i => ⨅ (_ : i < Nat.succ n✝), f iᶜ

tactic: rw [Nat.lt_succ_iff]
state_before: case succ.e_a.e_s.h
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
n✝ i : ℕ
⊢ (⨅ (_ : i ≤ n✝), f iᶜ) = ⨅ (_ : i < Nat.succ n✝), f iᶜ

tactic: rw [disjointed_zero, eq_comm, inf_eq_left]
state_before: case zero
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ disjointed f Nat.zero = f Nat.zero ⊓ ⨅ (i : ℕ) (_ : i < Nat.zero), f iᶜ

tactic: simp_rw [le_iInf_iff]
state_before: case zero
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ f Nat.zero ≤ ⨅ (i : ℕ) (_ : i < Nat.zero), f iᶜ

tactic: exact fun i hi => (i.not_lt_zero hi).elim
state_before: case zero
α : Type u_1
β : Type ?u.11805
inst✝ : CompleteBooleanAlgebra α
f : ℕ → α
⊢ ∀ (i : ℕ), i < Nat.zero → f Nat.zero ≤ f iᶜ
Theorem: Subsemigroup.coe_iSup_of_directed
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.1446
B : Type ?u.1449
inst✝ : Mul M
S : ι → Subsemigroup M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: Multiset.Nat.antidiagonal_succ_succ'
File: Mathlib/Data/Multiset/NatAntidiagonal.lean

tactic: rw [antidiagonal_succ, antidiagonal_succ', map_cons, map_map, Prod_map]
state_before: n : ℕ
⊢ antidiagonal (n + 2) = (0, n + 2) ::ₘ (n + 2, 0) ::ₘ map (Prod.map Nat.succ Nat.succ) (antidiagonal n)

tactic: rfl
state_before: n : ℕ
⊢ (0, n + 1 + 1) ::ₘ
      (Nat.succ (n + 1, 0).fst, id (n + 1, 0).snd) ::ₘ
        map (Prod.map Nat.succ id ∘ Prod.map id Nat.succ) (antidiagonal n) =
    (0, n + 2) ::ₘ (n + 2, 0) ::ₘ map (Prod.map Nat.succ Nat.succ) (antidiagonal n)
Theorem: Dfinsupp.sigmaCurry_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext (i j)
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.605040
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
⊢ sigmaCurry (f + g) = sigmaCurry f + sigmaCurry g

tactic: rw [@add_apply _ (fun i => Π₀ j, δ i j) _ (sigmaCurry _), add_apply, sigmaCurry_apply,
  sigmaCurry_apply, sigmaCurry_apply, add_apply]
state_before: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.605040
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
⊢ ↑(↑(sigmaCurry (f + g)) i) j = ↑(↑(sigmaCurry f + sigmaCurry g) i) j
Theorem: List.Nat.antidiagonalTuple_one
File: Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean

tactic: simp_rw [antidiagonalTuple, antidiagonal, List.range_succ, List.map_append, List.map_singleton,
  tsub_self, List.bind_append, List.bind_singleton, List.map_bind]
state_before: n : ℕ
⊢ antidiagonalTuple 1 n = [![n]]

tactic: conv_rhs => rw [← List.nil_append [![n]]]
state_before: n : ℕ
⊢ (List.bind (range n) fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [![n]]

tactic: congr 1
state_before: n : ℕ
⊢ (List.bind (range n) fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) ++
      map (fun x => Fin.cons n x) (antidiagonalTuple 0 0) =
    [] ++ [![n]]

tactic: simp_rw [List.bind_eq_nil, List.mem_range, List.map_eq_nil]
state_before: case e_a
n : ℕ
⊢ (List.bind (range n) fun a => map (fun x => Fin.cons a x) (antidiagonalTuple 0 (n - a))) = []

tactic: intro x hx
state_before: case e_a
n : ℕ
⊢ ∀ (x : ℕ), x < n → antidiagonalTuple 0 (n - x) = []

tactic: obtain ⟨m, rfl⟩ := Nat.exists_eq_add_of_lt hx
state_before: case e_a
n x : ℕ
hx : x < n
⊢ antidiagonalTuple 0 (n - x) = []

tactic: rw [add_assoc, add_tsub_cancel_left, antidiagonalTuple_zero_succ]
state_before: case e_a.intro
x m : ℕ
hx : x < x + m + 1
⊢ antidiagonalTuple 0 (x + m + 1 - x) = []
Theorem: Ordnode.all_node4R
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases m <;> simp [node4R, all_node', All, all_node3R, and_assoc]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ All P (node4R l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r
Theorem: Computation.mem_of_promises
File: Mathlib/Data/Seq/Computation.lean

tactic: cases' h with h
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
h : Terminates s
a : α
p : s ~> a
⊢ a ∈ s

tactic: cases' h with a' h
state_before: case mk
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
p : s ~> a
h : ∃ a, a ∈ s
⊢ a ∈ s

tactic: rw [p h]
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
p : s ~> a
a' : α
h : a' ∈ s
⊢ a ∈ s

tactic: exact h
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
p : s ~> a
a' : α
h : a' ∈ s
⊢ a' ∈ s
Theorem: SimpleGraph.Subgraph.IsMatching.toEdge_eq_of_adj
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: simp only [IsMatching.toEdge, Subtype.mk_eq_mk]
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
v w : V
hv : v ∈ M.verts
hvw : Adj M v w
⊢ toEdge h { val := v, property := hv } = { val := Quotient.mk (Sym2.Rel.setoid V) (v, w), property := hvw }

tactic: congr
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
v w : V
hv : v ∈ M.verts
hvw : Adj M v w
⊢ Quotient.mk (Sym2.Rel.setoid V) (v, Exists.choose (_ : ∃! w, Adj M (↑{ val := v, property := hv }) w)) =
    Quotient.mk (Sym2.Rel.setoid V) (v, w)

tactic: exact ((h (M.edge_vert hvw)).choose_spec.2 w hvw).symm
state_before: case e_a.e_snd
V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
v w : V
hv : v ∈ M.verts
hvw : Adj M v w
⊢ Exists.choose (_ : ∃! w, Adj M (↑{ val := v, property := hv }) w) = w
Theorem: CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal_inv
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: ext
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsTerminal X
⊢ (zeroIsoIsTerminal t).inv = 0
Theorem: CauSeq.exists_lt
File: Mathlib/Data/Real/CauSeq.lean

tactic: rwa [const_neg, sub_neg_eq_add, add_comm, ← sub_neg_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f : CauSeq α abs
a : α
h : -f < const a
⊢ Pos (f - const (-a))
Theorem: Metric.cthickening_subset_iUnion_closedBall_of_lt
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: refine' (cthickening_subset_thickening' hδ₀ hδδ' E).trans fun x hx => _
state_before: ι : Sort ?u.146791
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
E : Set α
δ δ' : ℝ
hδ₀ : 0 < δ'
hδδ' : δ < δ'
⊢ cthickening δ E ⊆ ⋃ (x : α) (_ : x ∈ E), closedBall x δ'

tactic: obtain ⟨y, hy₁, hy₂⟩ := mem_thickening_iff.mp hx
state_before: ι : Sort ?u.146791
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
E : Set α
δ δ' : ℝ
hδ₀ : 0 < δ'
hδδ' : δ < δ'
x : α
hx : x ∈ thickening δ' E
⊢ x ∈ ⋃ (x : α) (_ : x ∈ E), closedBall x δ'

tactic: exact mem_iUnion₂.mpr ⟨y, hy₁, hy₂.le⟩
state_before: case intro.intro
ι : Sort ?u.146791
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
E : Set α
δ δ' : ℝ
hδ₀ : 0 < δ'
hδδ' : δ < δ'
x : α
hx : x ∈ thickening δ' E
y : α
hy₁ : y ∈ E
hy₂ : dist x y < δ'
⊢ x ∈ ⋃ (x : α) (_ : x ∈ E), closedBall x δ'
Theorem: Filter.eq_biInf_of_mem_iff_exists_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.93784
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ (i : ι) (_ : p i), f i

tactic: exact eq_iInf_of_mem_iff_exists_mem <| fun {_} => by simp only [Subtype.exists, h, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.93784
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ (x : { i // p i }), f ↑x

tactic: simp only [Subtype.exists, h, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.93784
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
x✝ : Set α
⊢ x✝ ∈ l ↔ ∃ i, x✝ ∈ f ↑i
Theorem: List.count_not_add_count
File: Mathlib/Data/Bool/Count.lean

tactic: suffices : (fun x => x == b) = (fun a => decide ¬(a == !b) = true)
state_before: l : List Bool
b : Bool
⊢ countp (fun x => x == b) l = countp (fun a => decide ¬(a == !b) = true) l

tactic: rw [this]
state_before: l : List Bool
b : Bool
this : (fun x => x == b) = fun a => decide ¬(a == !b) = true
⊢ countp (fun x => x == b) l = countp (fun a => decide ¬(a == !b) = true) l

case this
l : List Bool
b : Bool
⊢ (fun x => x == b) = fun a => decide ¬(a == !b) = true

tactic: ext x
state_before: case this
l : List Bool
b : Bool
⊢ (fun x => x == b) = fun a => decide ¬(a == !b) = true

tactic: cases x <;> cases b <;> rfl
state_before: case this.h
l : List Bool
b x : Bool
⊢ (x == b) = decide ¬(x == !b) = true
Theorem: Int.Prime.dvd_mul'
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [Int.coe_nat_dvd_left, Int.coe_nat_dvd_left]
state_before: m n : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ m * n
⊢ ↑p ∣ m ∨ ↑p ∣ n

tactic: exact Int.Prime.dvd_mul hp h
state_before: m n : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ m * n
⊢ p ∣ natAbs m ∨ p ∣ natAbs n
Theorem: IsCoprime.symm
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm, H]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H✝ : IsCoprime x y
a b : R
H : a * x + b * y = 1
⊢ b * y + a * x = 1
Theorem: Complex.isOpen_setOf_mem_nhds_and_isMaxOn_norm
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: refine' isOpen_iff_mem_nhds.2 fun z hz => (eventually_eventually_nhds.2 hz.1).and _
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
⊢ IsOpen {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}

tactic: replace hd : ∀ᶠ w in 𝓝 z, DifferentiableAt ℂ f w
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
⊢ ∀ᶠ (z : E) in 𝓝 z, IsMaxOn (norm ∘ f) s z

tactic: exact hd.eventually_differentiableAt hz.1
state_before: case hd
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
⊢ ∀ᶠ (w : E) in 𝓝 z, DifferentiableAt ℂ f w

E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
hd : ∀ᶠ (w : E) in 𝓝 z, DifferentiableAt ℂ f w
⊢ ∀ᶠ (z : E) in 𝓝 z, IsMaxOn (norm ∘ f) s z

tactic: exact (norm_eventually_eq_of_isLocalMax hd <| hz.2.isLocalMax hz.1).mono fun x hx y hy =>
  le_trans (hz.2 hy).out hx.ge
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
hd : ∀ᶠ (w : E) in 𝓝 z, DifferentiableAt ℂ f w
⊢ ∀ᶠ (z : E) in 𝓝 z, IsMaxOn (norm ∘ f) s z
Theorem: Sym.cons_equiv_eq_equiv_cons
File: Mathlib/Data/Sym/Basic.lean

tactic: rcases s with ⟨⟨l⟩, _⟩
state_before: α✝ : Type ?u.27619
β : Type ?u.27622
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a✝ b : α✝
α : Type u_1
n : ℕ
a : α
s : Sym α n
⊢ (a :: ↑symEquivSym' s) = ↑symEquivSym' (a ::ₛ s)

tactic: rfl
state_before: case mk.mk
α✝ : Type ?u.27619
β : Type ?u.27622
n✝ n' m : ℕ
s : Sym α✝ n✝
a✝ b : α✝
α : Type u_1
n : ℕ
a : α
val✝ : Multiset α
l : List α
property✝ : ↑Multiset.card (Quot.mk Setoid.r l) = n
⊢ (a :: ↑symEquivSym' { val := Quot.mk Setoid.r l, property := property✝ }) =
    ↑symEquivSym' (a ::ₛ { val := Quot.mk Setoid.r l, property := property✝ })
Theorem: Complex.restrictScalars_one_smulRight'
File: Mathlib/Analysis/Complex/Basic.lean

tactic: ext ⟨a, b⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x : E
⊢ restrictScalars ℝ (smulRight 1 x) = smulRight reClm x + I • smulRight imClm x

tactic: simp [mk_eq_add_mul_I, mul_smul, smul_comm I b x]
state_before: case h.mk
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x : E
a b : ℝ
⊢ ↑(restrictScalars ℝ (smulRight 1 x)) { re := a, im := b } =
    ↑(smulRight reClm x + I • smulRight imClm x) { re := a, im := b }
Theorem: Ideal.kerLiftAlg_mk
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: rfl
state_before: R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type u_1
R₂ : Type ?u.819159
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
f : A →ₐ[R₁] B
a : A
⊢ ↑(kerLiftAlg f) (↑(Quotient.mk (RingHom.ker f)) a) = ↑f a
Theorem: IsROrC.div_I
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [div_eq_mul_inv, inv_I, mul_neg]
state_before: K : Type u_1
E : Type ?u.6059054
inst✝ : IsROrC K
z : K
⊢ z / I = -(z * I)
Theorem: SimpleGraph.Walk.map_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => simp [ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ Walk.map f' (Walk.map f p) = Walk.map (Hom.comp f' f) p

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
u✝ : V
⊢ Walk.map f' (Walk.map f nil) = Walk.map (Hom.comp f' f) nil

tactic: simp [ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : Walk.map f' (Walk.map f p✝) = Walk.map (Hom.comp f' f) p✝
⊢ Walk.map f' (Walk.map f (cons h✝ p✝)) = Walk.map (Hom.comp f' f) (cons h✝ p✝)
Theorem: Real.tendsto_Icc_vitaliFamily_left
File: Mathlib/MeasureTheory/Covering/OneDim.lean

tactic: refine' (VitaliFamily.tendsto_filterAt_iff _).2 ⟨_, _⟩
state_before: x : ℝ
⊢ Tendsto (fun y => Icc y x) (𝓝[Iio x] x) (VitaliFamily.filterAt (vitaliFamily volume 1) x)

tactic: filter_upwards [self_mem_nhdsWithin] with y hy using Icc_mem_vitaliFamily_at_left hy
state_before: case refine'_1
x : ℝ
⊢ ∀ᶠ (i : ℝ) in 𝓝[Iio x] x, Icc i x ∈ VitaliFamily.setsAt (vitaliFamily volume 1) x

tactic: intro ε εpos
state_before: case refine'_2
x : ℝ
⊢ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (i : ℝ) in 𝓝[Iio x] x, Icc i x ⊆ Metric.closedBall x ε

tactic: have : x ∈ Ioc (x - ε) x := ⟨by linarith, le_refl _⟩
state_before: case refine'_2
x ε : ℝ
εpos : ε > 0
⊢ ∀ᶠ (i : ℝ) in 𝓝[Iio x] x, Icc i x ⊆ Metric.closedBall x ε

tactic: filter_upwards [Icc_mem_nhdsWithin_Iio this] with y hy
state_before: case refine'_2
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
⊢ ∀ᶠ (i : ℝ) in 𝓝[Iio x] x, Icc i x ⊆ Metric.closedBall x ε

tactic: rw [closedBall_eq_Icc]
state_before: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Metric.closedBall x ε

tactic: exact Icc_subset_Icc hy.1 (by linarith)
state_before: case h
x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ Icc y x ⊆ Icc (x - ε) (x + ε)

tactic: linarith
state_before: x ε : ℝ
εpos : ε > 0
⊢ x - ε < x

tactic: linarith
state_before: x ε : ℝ
εpos : ε > 0
this : x ∈ Ioc (x - ε) x
y : ℝ
hy : y ∈ Icc (x - ε) x
⊢ x ≤ x + ε