tasksource/leandojo huggingface dataset:
Theorem: linearIndependent_option
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp only [← linearIndependent_option', Option.casesOn'_none_coe]
state_before: ι : Type u'
ι' : Type ?u.1220994
R : Type ?u.1220997
K : Type u_1
M : Type ?u.1221003
M' : Type ?u.1221006
M'' : Type ?u.1221009
V : Type u
V' : Type ?u.1221014
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
v : Option ι → V
⊢ LinearIndependent K v ↔ LinearIndependent K (v ∘ some) ∧ ¬v none ∈ span K (range (v ∘ some))
Theorem: Group.normalClosure.is_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: induction' h with x hx x hx ihx x y hx hy ihx ihy
state_before: G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n : G
h : n ∈ normalClosure s
g : G
⊢ g * n * g⁻¹ ∈ normalClosure s

tactic: exact conjugatesOfSet_subset_normalClosure (conj_mem_conjugatesOfSet hx)
state_before: case basic
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g x : G
hx : x ∈ conjugatesOfSet s
⊢ g * x * g⁻¹ ∈ normalClosure s

tactic: simpa using (normalClosure.isSubgroup s).one_mem
state_before: case one
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g : G
⊢ g * 1 * g⁻¹ ∈ normalClosure s

tactic: rw [← conj_inv]
state_before: case inv
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g x : G
hx : InClosure (conjugatesOfSet s) x
ihx : g * x * g⁻¹ ∈ normalClosure s
⊢ g * x⁻¹ * g⁻¹ ∈ normalClosure s

tactic: exact (normalClosure.isSubgroup _).inv_mem ihx
state_before: case inv
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g x : G
hx : InClosure (conjugatesOfSet s) x
ihx : g * x * g⁻¹ ∈ normalClosure s
⊢ (g * x * g⁻¹)⁻¹ ∈ normalClosure s

tactic: rw [← conj_mul]
state_before: case mul
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g x y : G
hx : InClosure (conjugatesOfSet s) x
hy : InClosure (conjugatesOfSet s) y
ihx : g * x * g⁻¹ ∈ normalClosure s
ihy : g * y * g⁻¹ ∈ normalClosure s
⊢ g * (x * y) * g⁻¹ ∈ normalClosure s

tactic: exact (normalClosure.isSubgroup _).toIsSubmonoid.mul_mem ihx ihy
state_before: case mul
G : Type u_1
H : Type ?u.144028
A : Type ?u.144031
a a₁ a₂ b c : G
s : Set G
inst✝ : Group G
src✝ : IsSubgroup (normalClosure s) := isSubgroup s
n g x y : G
hx : InClosure (conjugatesOfSet s) x
hy : InClosure (conjugatesOfSet s) y
ihx : g * x * g⁻¹ ∈ normalClosure s
ihy : g * y * g⁻¹ ∈ normalClosure s
⊢ g * x * g⁻¹ * (g * y * g⁻¹) ∈ normalClosure s
Theorem: Doset.doset_eq_of_mem
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: obtain ⟨_, k, ⟨h, a, hh, rfl : _ = _, rfl⟩, hk, rfl⟩ := hb
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.4114
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
hb : b ∈ doset a ↑H ↑K
⊢ doset b ↑H ↑K = doset a ↑H ↑K

tactic: rw [doset, doset, ← Set.singleton_mul_singleton, ← Set.singleton_mul_singleton, mul_assoc,
  mul_assoc, Subgroup.singleton_mul_subgroup hk, ← mul_assoc, ← mul_assoc,
  Subgroup.subgroup_mul_singleton hh]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.4114
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
k h a : G
hh : h ∈ ↑H
hk : k ∈ ↑K
⊢ doset ((fun x x_1 => x * x_1) ((fun x x_1 => x * x_1) h a) k) ↑H ↑K = doset a ↑H ↑K
Theorem: Cardinal.mk_emptyCollection_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: constructor
state_before: α✝ β α : Type u
s : Set α
⊢ (#↑s) = 0 ↔ s = ∅

tactic: intro h
state_before: case mp
α✝ β α : Type u
s : Set α
⊢ (#↑s) = 0 → s = ∅

tactic: rw [mk_eq_zero_iff] at h
state_before: case mp
α✝ β α : Type u
s : Set α
h : (#↑s) = 0
⊢ s = ∅

tactic: exact eq_empty_iff_forall_not_mem.2 fun x hx => h.elim' ⟨x, hx⟩
state_before: case mp
α✝ β α : Type u
s : Set α
h : IsEmpty ↑s
⊢ s = ∅

tactic: rintro rfl
state_before: case mpr
α✝ β α : Type u
s : Set α
⊢ s = ∅ → (#↑s) = 0

tactic: exact mk_emptyCollection _
state_before: case mpr
α✝ β α : Type u
⊢ (#↑∅) = 0
Theorem: Filter.pi_mem_pi
File: Mathlib/Order/Filter/Pi.lean

tactic: rw [pi_def, biInter_eq_iInter]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
I : Set ι
hI : Set.Finite I
h : ∀ (i : ι), i ∈ I → s i ∈ f i
⊢ Set.pi I s ∈ pi f

tactic: refine' mem_iInf_of_iInter hI (fun i => _) Subset.rfl
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
I : Set ι
hI : Set.Finite I
h : ∀ (i : ι), i ∈ I → s i ∈ f i
⊢ (⋂ (x : ↑I), eval ↑x ⁻¹' s ↑x) ∈ pi f

tactic: exact preimage_mem_comap (h i i.2)
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
I : Set ι
hI : Set.Finite I
h : ∀ (i : ι), i ∈ I → s i ∈ f i
i : ↑I
⊢ eval ↑i ⁻¹' s ↑i ∈ comap (eval ↑i) (f ↑i)
Theorem: Part.get_eq_get_of_eq
File: Mathlib/Data/Part.lean

tactic: congr
state_before: α : Type u_1
β : Type ?u.6349
γ : Type ?u.6352
a : Part α
ha : a.Dom
b : Part α
h : a = b
⊢ get a ha = get b (_ : b.Dom)
Theorem: Set.ite_inter_inter
File: Mathlib/Data/Set/Basic.lean

tactic: ext x
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁✝ s₂✝ t✝ t₁ t₂ u t s₁ s₂ s₁' s₂' : Set α
⊢ Set.ite t (s₁ ∩ s₂) (s₁' ∩ s₂') = Set.ite t s₁ s₁' ∩ Set.ite t s₂ s₂'

tactic: simp only [Set.ite, Set.mem_inter_iff, Set.mem_diff, Set.mem_union]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁✝ s₂✝ t✝ t₁ t₂ u t s₁ s₂ s₁' s₂' : Set α
x : α
⊢ x ∈ Set.ite t (s₁ ∩ s₂) (s₁' ∩ s₂') ↔ x ∈ Set.ite t s₁ s₁' ∩ Set.ite t s₂ s₂'

tactic: tauto
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁✝ s₂✝ t✝ t₁ t₂ u t s₁ s₂ s₁' s₂' : Set α
x : α
⊢ (x ∈ s₁ ∧ x ∈ s₂) ∧ x ∈ t ∨ (x ∈ s₁' ∧ x ∈ s₂') ∧ ¬x ∈ t ↔
    (x ∈ s₁ ∧ x ∈ t ∨ x ∈ s₁' ∧ ¬x ∈ t) ∧ (x ∈ s₂ ∧ x ∈ t ∨ x ∈ s₂' ∧ ¬x ∈ t)
Theorem: Multiset.toFinset_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← cons_zero, toFinset_cons, toFinset_zero, IsLawfulSingleton.insert_emptyc_eq]
state_before: α : Type u_1
β : Type ?u.445536
γ : Type ?u.445539
inst✝ : DecidableEq α
s t : Multiset α
a : α
⊢ toFinset {a} = {a}
Theorem: List.foldr_self_append
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
l' l : List α
⊢ foldr cons l' l = l ++ l'
Theorem: Int.fmod_one
File: Std/Data/Int/DivMod.lean

tactic: simp [fmod_def, Int.one_mul, Int.sub_self]
state_before: a : Int
⊢ fmod a 1 = 0
Theorem: AlgebraicTopology.DoldKan.inclusionOfMooreComplexMap_comp_PInfty
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

tactic: ext (_|n)
state_before: A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X✝ X : SimplicialObject A
⊢ inclusionOfMooreComplexMap X ≫ PInfty = inclusionOfMooreComplexMap X

tactic: dsimp
state_before: case h.zero
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X✝ X : SimplicialObject A
⊢ HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X ≫ PInfty) Nat.zero =
    HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X) Nat.zero

tactic: simp only [comp_id]
state_before: case h.zero
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X✝ X : SimplicialObject A
⊢ HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X) 0 ≫ 𝟙 (X.obj (SimplexCategory.mk 0).op) =
    HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X) 0

tactic: exact (HigherFacesVanish.inclusionOfMooreComplexMap n).comp_P_eq_self
state_before: case h.succ
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X✝ X : SimplicialObject A
n : ℕ
⊢ HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X ≫ PInfty) (Nat.succ n) =
    HomologicalComplex.Hom.f (inclusionOfMooreComplexMap X) (Nat.succ n)
Theorem: HasSum.neg
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa only using h.map (-AddMonoidHom.id α) continuous_neg
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.395925
δ : Type ?u.395928
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f g : β → α
a a₁ a₂ : α
h : HasSum f a
⊢ HasSum (fun b => -f b) (-a)
Theorem: continuousOn_multiset_prod
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rcases s with ⟨l⟩
state_before: ι : Type u_1
α : Type ?u.433203
X : Type u_2
M : Type u_3
N : Type ?u.433212
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
t : Set X
⊢ (∀ (i : ι), i ∈ s → ContinuousOn (f i) t) → ContinuousOn (fun a => Multiset.prod (Multiset.map (fun i => f i a) s)) t

tactic: simpa using continuousOn_list_prod l
state_before: case mk
ι : Type u_1
α : Type ?u.433203
X : Type u_2
M : Type u_3
N : Type ?u.433212
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → X → M
s : Multiset ι
t : Set X
l : List ι
⊢ (∀ (i : ι), i ∈ Quot.mk Setoid.r l → ContinuousOn (f i) t) →
    ContinuousOn (fun a => Multiset.prod (Multiset.map (fun i => f i a) (Quot.mk Setoid.r l))) t
Theorem: Matrix.conjTranspose_row
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1214447
m : Type u_1
n : Type ?u.1214453
o : Type ?u.1214456
m' : o → Type ?u.1214461
n' : o → Type ?u.1214466
R : Type ?u.1214469
S : Type ?u.1214472
α : Type v
β : Type w
γ : Type ?u.1214479
inst✝ : Star α
v : m → α
⊢ (row v)ᴴ = col (star v)

tactic: rfl
state_before: case a.h
l : Type ?u.1214447
m : Type u_1
n : Type ?u.1214453
o : Type ?u.1214456
m' : o → Type ?u.1214461
n' : o → Type ?u.1214466
R : Type ?u.1214469
S : Type ?u.1214472
α : Type v
β : Type w
γ : Type ?u.1214479
inst✝ : Star α
v : m → α
i✝ : m
x✝ : Unit
⊢ (row v)ᴴ i✝ x✝ = col (star v) i✝ x✝
Theorem: Equiv.Perm.zpow_apply_comm
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: rw [← Equiv.Perm.mul_apply, ← Equiv.Perm.mul_apply, zpow_mul_comm]
state_before: α✝ : Type u
β : Type v
α : Type u_1
σ : Perm α
m n : ℤ
x : α
⊢ ↑(σ ^ m) (↑(σ ^ n) x) = ↑(σ ^ n) (↑(σ ^ m) x)
Theorem: IsSemiringHom.comp
File: Mathlib/Deprecated/Ring.lean

tactic: simpa [map_zero hf] using map_zero hg
state_before: α : Type u
β : Type v
inst✝² : Semiring α
inst✝¹ : Semiring β
f : α → β
hf✝ : IsSemiringHom f
x y : α
hf : IsSemiringHom f
γ : Type u_1
inst✝ : Semiring γ
g : β → γ
hg : IsSemiringHom g
⊢ (g ∘ f) 0 = 0

tactic: simpa [map_one hf] using map_one hg
state_before: α : Type u
β : Type v
inst✝² : Semiring α
inst✝¹ : Semiring β
f : α → β
hf✝ : IsSemiringHom f
x y : α
hf : IsSemiringHom f
γ : Type u_1
inst✝ : Semiring γ
g : β → γ
hg : IsSemiringHom g
⊢ (g ∘ f) 1 = 1

tactic: simp [map_add hf, map_add hg]
state_before: α : Type u
β : Type v
inst✝² : Semiring α
inst✝¹ : Semiring β
f : α → β
hf✝ : IsSemiringHom f
x✝ y✝ : α
hf : IsSemiringHom f
γ : Type u_1
inst✝ : Semiring γ
g : β → γ
hg : IsSemiringHom g
x y : α
⊢ (g ∘ f) (x + y) = (g ∘ f) x + (g ∘ f) y

tactic: simp [map_mul hf, map_mul hg]
state_before: α : Type u
β : Type v
inst✝² : Semiring α
inst✝¹ : Semiring β
f : α → β
hf✝ : IsSemiringHom f
x✝ y✝ : α
hf : IsSemiringHom f
γ : Type u_1
inst✝ : Semiring γ
g : β → γ
hg : IsSemiringHom g
x y : α
⊢ (g ∘ f) (x * y) = (g ∘ f) x * (g ∘ f) y
Theorem: finrank_eq_zero
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← rank_eq_zero, ← finrank_eq_rank, ← @Nat.cast_zero Cardinal, Cardinal.natCast_inj]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
S : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S }
⊢ finrank K { x // x ∈ S } = 0 ↔ S = ⊥
Theorem: Finset.prod_ite_of_true
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp_rw [← ite_not (p _)]
state_before: ι : Type ?u.405265
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → β
h : ∀ (x : α), x ∈ s → p x
⊢ (∏ x in s, if p x then f x else g x) = ∏ x in s, f x

tactic: apply prod_ite_of_false
state_before: ι : Type ?u.405265
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → β
h : ∀ (x : α), x ∈ s → p x
⊢ (∏ x in s, if ¬p x then g x else f x) = ∏ x in s, f x

tactic: simpa
state_before: case h
ι : Type ?u.405265
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → β
h : ∀ (x : α), x ∈ s → p x
⊢ ∀ (x : α), x ∈ s → ¬¬p x
Theorem: Nat.le_mul_of_pos_left
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: conv =>
  lhs
  rw [← one_mul m]
state_before: m n k l : ℕ
h : 0 < n
⊢ m ≤ n * m

tactic: exact mul_le_mul_of_nonneg_right h.nat_succ_le (zero_le _)
state_before: m n k l : ℕ
h : 0 < n
⊢ 1 * m ≤ n * m
Theorem: Set.offDiag_empty
File: Mathlib/Data/Set/Prod.lean

tactic: simp
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
⊢ offDiag ∅ = ∅
Theorem: ENNReal.coe_tsum
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [hr.tsum_eq, ENNReal.tsum_coe_eq hr]
state_before: α : Type u_1
β : Type ?u.231026
γ : Type ?u.231029
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : α → ℝ≥0
r : ℝ≥0
hr : HasSum f r
⊢ ↑(tsum f) = ∑' (a : α), ↑(f a)
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [pullbackZeroZeroIso]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).inv ≫ pullback.snd = prod.snd

tactic: simp
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (limit.isoLimitCone
          { cone := PullbackCone.mk prod.fst prod.snd (_ : prod.fst ≫ 0 = prod.snd ≫ 0),
            isLimit :=
              isPullbackOfIsTerminalIsProduct 0 0 prod.fst prod.snd HasZeroObject.zeroIsTerminal
                (prodIsProd X Y) }).inv ≫
      pullback.snd =
    prod.snd
Theorem: MeasureTheory.hasFiniteIntegral_const_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [HasFiniteIntegral, lintegral_const, lt_top_iff_ne_top, ENNReal.mul_eq_top,
  or_iff_not_imp_left]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.708905
δ : Type ?u.708908
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
c : β
⊢ (HasFiniteIntegral fun x => c) ↔ c = 0 ∨ ↑↑μ univ < ⊤
Theorem: AffineMap.lineMap_eq_left_iff
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← @lineMap_eq_lineMap_iff k V1, lineMap_apply_zero]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type ?u.472756
P2 : Type ?u.472759
V3 : Type ?u.472762
P3 : Type ?u.472765
V4 : Type ?u.472768
P4 : Type ?u.472771
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V1
inst✝¹¹ : Module k V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : Module k V2
inst✝⁷ : AffineSpace V2 P2
inst✝⁶ : AddCommGroup V3
inst✝⁵ : Module k V3
inst✝⁴ : AffineSpace V3 P3
inst✝³ : AddCommGroup V4
inst✝² : Module k V4
inst✝¹ : AffineSpace V4 P4
inst✝ : NoZeroSMulDivisors k V1
p₀ p₁ : P1
c : k
⊢ ↑(lineMap p₀ p₁) c = p₀ ↔ p₀ = p₁ ∨ c = 0
Theorem: mem_closure_of_mem_closure_union
File: Mathlib/Topology/Basic.lean

tactic: rw [mem_closure_iff_nhds_neBot] at *
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁✝ s₂✝ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
x : α
h : x ∈ closure (s₁ ∪ s₂)
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ x ∈ closure s₂

tactic: rwa [←
  calc
    𝓝 x ⊓ principal (s₁ ∪ s₂) = 𝓝 x ⊓ (principal s₁ ⊔ principal s₂) := by rw [sup_principal]
    _ = 𝓝 x ⊓ principal s₁ ⊔ 𝓝 x ⊓ principal s₂ := inf_sup_left
    _ = ⊥ ⊔ 𝓝 x ⊓ principal s₂ := by rw [inf_principal_eq_bot.mpr h₁]
    _ = 𝓝 x ⊓ principal s₂ := bot_sup_eq
    ]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁✝ s₂✝ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
x : α
h : 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) ≠ ⊥
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ 𝓝 x ⊓ 𝓟 s₂ ≠ ⊥

tactic: rw [sup_principal]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁✝ s₂✝ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
x : α
h : 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) ≠ ⊥
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) = 𝓝 x ⊓ (𝓟 s₁ ⊔ 𝓟 s₂)

tactic: rw [inf_principal_eq_bot.mpr h₁]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁✝ s₂✝ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s₁ s₂ : Set α
x : α
h : 𝓝 x ⊓ 𝓟 (s₁ ∪ s₂) ≠ ⊥
h₁ : s₁ᶜ ∈ 𝓝 x
⊢ 𝓝 x ⊓ 𝓟 s₁ ⊔ 𝓝 x ⊓ 𝓟 s₂ = ⊥ ⊔ 𝓝 x ⊓ 𝓟 s₂
Theorem: conjugate_le_conjugate
File: Mathlib/Algebra/Star/Order.lean

tactic: rw [StarOrderedRing.le_iff] at hab ⊢
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a b : R
hab : a ≤ b
c : R
⊢ star c * a * c ≤ star c * b * c

tactic: obtain ⟨p, hp, rfl⟩ := hab
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a b : R
hab✝ : a ≤ b
hab : ∃ p, p ∈ AddSubmonoid.closure (Set.range fun s => star s * s) ∧ b = a + p
c : R
⊢ ∃ p, p ∈ AddSubmonoid.closure (Set.range fun s => star s * s) ∧ star c * b * c = star c * a * c + p

tactic: simp_rw [← StarOrderedRing.nonneg_iff] at hp ⊢
state_before: case intro.intro
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a c p : R
hp : p ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
hab : a ≤ a + p
⊢ ∃ p_1, p_1 ∈ AddSubmonoid.closure (Set.range fun s => star s * s) ∧ star c * (a + p) * c = star c * a * c + p_1

tactic: exact ⟨star c * p * c, conjugate_nonneg hp c, by simp only [add_mul, mul_add]⟩
state_before: case intro.intro
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a c p : R
hab : a ≤ a + p
hp : 0 ≤ p
⊢ ∃ p_1, 0 ≤ p_1 ∧ star c * (a + p) * c = star c * a * c + p_1

tactic: simp only [add_mul, mul_add]
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a c p : R
hab : a ≤ a + p
hp : 0 ≤ p
⊢ star c * (a + p) * c = star c * a * c + star c * p * c
Theorem: Mathlib.Tactic.Ring.pow_nat
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
b c k : ℕ
a d e : R
x✝² : b = c * k
x✝¹ : a ^ c = d
x✝ : d ^ k = e
⊢ a ^ b = e

tactic: simp [pow_mul]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
c k : ℕ
a : R
⊢ a ^ (c * k) = (a ^ c) ^ k
Theorem: PrimrecPred.or
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.133356
γ : Type ?u.133359
δ : Type ?u.133362
σ : Type ?u.133365
inst✝⁶ : Primcodable α
inst✝⁵ : Primcodable β
inst✝⁴ : Primcodable γ
inst✝³ : Primcodable δ
inst✝² : Primcodable σ
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
hp : PrimrecPred p
hq : PrimrecPred q
n : α
⊢ (decide (p n) || decide (q n)) = decide ((fun a => p a ∨ q a) n)
Theorem: CategoryTheory.transferNatTransSelf_symm_comm
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: rw [transferNatTransSelf_symm_comp, gf, transferNatTransSelf_symm_id]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₁ ⟶ R₂
g : R₂ ⟶ R₁
gf : g ≫ f = 𝟙 R₂
⊢ ↑(transferNatTransSelf adj₁ adj₂).symm f ≫ ↑(transferNatTransSelf adj₂ adj₁).symm g = 𝟙 L₂
Theorem: Nat.Prime.multiplicity_factorial_mul
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: induction' n with n ih
state_before: n p : ℕ
hp : Prime p
⊢ multiplicity p (p * n)! = multiplicity p n ! + ↑n

tactic: simp
state_before: case zero
p : ℕ
hp : Prime p
⊢ multiplicity p (p * zero)! = multiplicity p zero ! + ↑zero

tactic: simp only [succ_eq_add_one, multiplicity.mul, hp, hp.prime, ih, multiplicity_factorial_mul_succ,
  ← add_assoc, Nat.cast_one, Nat.cast_add, factorial_succ]
state_before: case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p (p * succ n)! = multiplicity p (succ n)! + ↑(succ n)

tactic: congr 1
state_before: case succ
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) + 1 = multiplicity p (n + 1) + multiplicity p n ! + ↑n + 1

tactic: rw [add_comm, add_assoc]
state_before: case succ.e_a
p : ℕ
hp : Prime p
n : ℕ
ih : multiplicity p (p * n)! = multiplicity p n ! + ↑n
⊢ multiplicity p n ! + ↑n + multiplicity p (n + 1) = multiplicity p (n + 1) + multiplicity p n ! + ↑n
Theorem: PadicInt.denseRange_nat_cast
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: intro x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ DenseRange Nat.cast

tactic: rw [Metric.mem_closure_range_iff]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ closure (Set.range Nat.cast)

tactic: intro ε hε
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (ε : ℝ), ε > 0 → ∃ k, dist x ↑k < ε

tactic: obtain ⟨n, hn⟩ := exists_pow_neg_lt p hε
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
⊢ ∃ k, dist x ↑k < ε

tactic: use x.appr n
state_before: case intro
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
n : ℕ
hn : ↑p ^ (-↑n) < ε
⊢ ∃ k, dist x ↑k < ε

tactic: rw [dist_eq_norm]
state_before: case intro
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
n : ℕ
hn : ↑p ^ (-↑n) < ε
⊢ dist x ↑(appr x n) < ε

tactic: apply lt_of_le_of_lt _ hn
state_before: case intro
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
n : ℕ
hn : ↑p ^ (-↑n) < ε
⊢ ‖x - ↑(appr x n)‖ < ε

tactic: rw [norm_le_pow_iff_mem_span_pow]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
n : ℕ
hn : ↑p ^ (-↑n) < ε
⊢ ‖x - ↑(appr x n)‖ ≤ ↑p ^ (-↑n)

tactic: apply appr_spec
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
ε : ℝ
hε : ε > 0
n : ℕ
hn : ↑p ^ (-↑n) < ε
⊢ x - ↑(appr x n) ∈ Ideal.span {↑p ^ n}
Theorem: Array.size_ofFn
File: Std/Data/Array/Lemmas.lean

tactic: simp [ofFn]
state_before: n : Nat
α : Type u_1
f : Fin n → α
⊢ size (ofFn f) = n
Theorem: Equiv.Perm.Disjoint.mul_apply_eq_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine' ⟨fun h => _, fun h => by rw [mul_apply, h.2, h.1]⟩
state_before: α : Type u_1
f g h σ τ : Perm α
hστ : Disjoint σ τ
a : α
⊢ ↑(σ * τ) a = a ↔ ↑σ a = a ∧ ↑τ a = a

tactic: cases' hστ a with hσ hτ
state_before: α : Type u_1
f g h✝ σ τ : Perm α
hστ : Disjoint σ τ
a : α
h : ↑(σ * τ) a = a
⊢ ↑σ a = a ∧ ↑τ a = a

tactic: rw [mul_apply, h.2, h.1]
state_before: α : Type u_1
f g h✝ σ τ : Perm α
hστ : Disjoint σ τ
a : α
h : ↑σ a = a ∧ ↑τ a = a
⊢ ↑(σ * τ) a = a

tactic: exact ⟨hσ, σ.injective (h.trans hσ.symm)⟩
state_before: case inl
α : Type u_1
f g h✝ σ τ : Perm α
hστ : Disjoint σ τ
a : α
h : ↑(σ * τ) a = a
hσ : ↑σ a = a
⊢ ↑σ a = a ∧ ↑τ a = a

tactic: exact ⟨(congr_arg σ hτ).symm.trans h, hτ⟩
state_before: case inr
α : Type u_1
f g h✝ σ τ : Perm α
hστ : Disjoint σ τ
a : α
h : ↑(σ * τ) a = a
hτ : ↑τ a = a
⊢ ↑σ a = a ∧ ↑τ a = a
Theorem: nhds_basis_Ioo_pos
File: Mathlib/Topology/Order/Basic.lean

tactic: convert nhds_basis_abs_sub_lt a
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrderedAddCommGroup α
inst✝¹ : OrderTopology α
l : Filter β
f g : β → α
inst✝ : NoMaxOrder α
a : α
⊢ HasBasis (𝓝 a) (fun ε => 0 < ε) fun ε => Ioo (a - ε) (a + ε)

tactic: simp only [Ioo, abs_lt, ← sub_lt_iff_lt_add, neg_lt_sub_iff_lt_add, sub_lt_comm]
state_before: case h.e'_5.h
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrderedAddCommGroup α
inst✝¹ : OrderTopology α
l : Filter β
f g : β → α
inst✝ : NoMaxOrder α
a x✝ : α
⊢ Ioo (a - x✝) (a + x✝) = {b | abs (b - a) < x✝}