tasksource/leandojo huggingface dataset:
Theorem: Finsupp.mulHom_ext
File: Mathlib/Data/Finsupp/Defs.lean

tactic: have := @addHom_ext α M (Additive N) _ _
  (MonoidHom.toAdditive'' f) (MonoidHom.toAdditive'' g) H
state_before: α : Type u_3
β : Type ?u.347410
γ : Type ?u.347413
ι : Type ?u.347416
M : Type u_2
M' : Type ?u.347422
N : Type u_1
P : Type ?u.347428
G : Type ?u.347431
H✝ : Type ?u.347434
R : Type ?u.347437
S : Type ?u.347440
inst✝¹ : AddZeroClass M
inst✝ : MulOneClass N
f g : Multiplicative (α →₀ M) →* N
H : ∀ (x : α) (y : M), ↑f (↑Multiplicative.ofAdd (single x y)) = ↑g (↑Multiplicative.ofAdd (single x y))
⊢ f = g

tactic: ext
state_before: α : Type u_3
β : Type ?u.347410
γ : Type ?u.347413
ι : Type ?u.347416
M : Type u_2
M' : Type ?u.347422
N : Type u_1
P : Type ?u.347428
G : Type ?u.347431
H✝ : Type ?u.347434
R : Type ?u.347437
S : Type ?u.347440
inst✝¹ : AddZeroClass M
inst✝ : MulOneClass N
f g : Multiplicative (α →₀ M) →* N
H : ∀ (x : α) (y : M), ↑f (↑Multiplicative.ofAdd (single x y)) = ↑g (↑Multiplicative.ofAdd (single x y))
this : ↑MonoidHom.toAdditive'' f = ↑MonoidHom.toAdditive'' g
⊢ f = g

tactic: rw [FunLike.ext_iff] at this
state_before: case h
α : Type u_3
β : Type ?u.347410
γ : Type ?u.347413
ι : Type ?u.347416
M : Type u_2
M' : Type ?u.347422
N : Type u_1
P : Type ?u.347428
G : Type ?u.347431
H✝ : Type ?u.347434
R : Type ?u.347437
S : Type ?u.347440
inst✝¹ : AddZeroClass M
inst✝ : MulOneClass N
f g : Multiplicative (α →₀ M) →* N
H : ∀ (x : α) (y : M), ↑f (↑Multiplicative.ofAdd (single x y)) = ↑g (↑Multiplicative.ofAdd (single x y))
this : ↑MonoidHom.toAdditive'' f = ↑MonoidHom.toAdditive'' g
x✝ : Multiplicative (α →₀ M)
⊢ ↑f x✝ = ↑g x✝

tactic: apply this
state_before: case h
α : Type u_3
β : Type ?u.347410
γ : Type ?u.347413
ι : Type ?u.347416
M : Type u_2
M' : Type ?u.347422
N : Type u_1
P : Type ?u.347428
G : Type ?u.347431
H✝ : Type ?u.347434
R : Type ?u.347437
S : Type ?u.347440
inst✝¹ : AddZeroClass M
inst✝ : MulOneClass N
f g : Multiplicative (α →₀ M) →* N
H : ∀ (x : α) (y : M), ↑f (↑Multiplicative.ofAdd (single x y)) = ↑g (↑Multiplicative.ofAdd (single x y))
this✝ : ↑MonoidHom.toAdditive'' f = ↑MonoidHom.toAdditive'' g
this : ∀ (x : α →₀ M), ↑(↑MonoidHom.toAdditive'' f) x = ↑(↑MonoidHom.toAdditive'' g) x
x✝ : Multiplicative (α →₀ M)
⊢ ↑f x✝ = ↑g x✝
Theorem: Finset.mem_upShadow_iff_erase_mem
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: refine' mem_upShadow_iff.trans ⟨_, _⟩
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ s ∈ (∂⁺ ) 𝒜 ↔ ∃ a, a ∈ s ∧ erase s a ∈ 𝒜

tactic: rintro ⟨s, hs, a, ha, rfl⟩
state_before: case refine'_1
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ t, t ∈ 𝒜 ∧ ∃ a x, insert a t = s) → ∃ a, a ∈ s ∧ erase s a ∈ 𝒜

tactic: refine' ⟨a, mem_insert_self a s, _⟩
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : ¬a ∈ s
⊢ ∃ a_1, a_1 ∈ insert a s ∧ erase (insert a s) a_1 ∈ 𝒜

tactic: rwa [erase_insert ha]
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
t : Finset α
a✝ : α
k r : ℕ
s : Finset α
hs : s ∈ 𝒜
a : α
ha : ¬a ∈ s
⊢ erase (insert a s) a ∈ 𝒜

tactic: rintro ⟨a, ha, hs⟩
state_before: case refine'_2
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ a, a ∈ s ∧ erase s a ∈ 𝒜) → ∃ t, t ∈ 𝒜 ∧ ∃ a x, insert a t = s

tactic: exact ⟨s.erase a, hs, a, not_mem_erase _ _, insert_erase ha⟩
state_before: case refine'_2.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a✝ : α
k r : ℕ
a : α
ha : a ∈ s
hs : erase s a ∈ 𝒜
⊢ ∃ t, t ∈ 𝒜 ∧ ∃ a x, insert a t = s
Theorem: LocallyFinite.closure_iUnion
File: Mathlib/Topology/LocallyFinite.lean

tactic: ext x
state_before: ι : Type u_1
ι' : Type ?u.7433
α : Type ?u.7436
X : Type u_2
Y : Type ?u.7442
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
h : LocallyFinite f
⊢ closure (⋃ (i : ι), f i) = ⋃ (i : ι), closure (f i)

tactic: simp only [mem_closure_iff_nhdsWithin_neBot, h.nhdsWithin_iUnion, iSup_neBot, mem_iUnion]
state_before: case h
ι : Type u_1
ι' : Type ?u.7433
α : Type ?u.7436
X : Type u_2
Y : Type ?u.7442
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
h : LocallyFinite f
x : X
⊢ x ∈ closure (⋃ (i : ι), f i) ↔ x ∈ ⋃ (i : ι), closure (f i)
Theorem: Bool.true_and
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (true && b) = b
Theorem: Complex.tan_mul_cos
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [tan_eq_sin_div_cos, div_mul_cancel _ hx]
state_before: x✝ y x : ℂ
hx : cos x ≠ 0
⊢ tan x * cos x = sin x
Theorem: Finsupp.single_of_single_apply
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [single_apply, single_apply]
state_before: α : Type u_1
β : Type ?u.44418
γ : Type ?u.44421
ι : Type ?u.44424
M : Type u_2
M' : Type ?u.44430
N : Type ?u.44433
P : Type ?u.44436
G : Type ?u.44439
H : Type ?u.44442
R : Type ?u.44445
S : Type ?u.44448
inst✝ : Zero M
a✝ a'✝ : α
b✝ : M
a a' : α
b : M
⊢ single a (↑(single a' b) a) = ↑(single a' (single a' b)) a

tactic: ext
state_before: α : Type u_1
β : Type ?u.44418
γ : Type ?u.44421
ι : Type ?u.44424
M : Type u_2
M' : Type ?u.44430
N : Type ?u.44433
P : Type ?u.44436
G : Type ?u.44439
H : Type ?u.44442
R : Type ?u.44445
S : Type ?u.44448
inst✝ : Zero M
a✝ a'✝ : α
b✝ : M
a a' : α
b : M
⊢ single a (if a' = a then b else 0) = if a' = a then single a' b else 0

tactic: split_ifs with h
state_before: case h
α : Type u_1
β : Type ?u.44418
γ : Type ?u.44421
ι : Type ?u.44424
M : Type u_2
M' : Type ?u.44430
N : Type ?u.44433
P : Type ?u.44436
G : Type ?u.44439
H : Type ?u.44442
R : Type ?u.44445
S : Type ?u.44448
inst✝ : Zero M
a✝¹ a'✝ : α
b✝ : M
a a' : α
b : M
a✝ : α
⊢ ↑(single a (if a' = a then b else 0)) a✝ = ↑(if a' = a then single a' b else 0) a✝

tactic: rw [h]
state_before: case h.inl
α : Type u_1
β : Type ?u.44418
γ : Type ?u.44421
ι : Type ?u.44424
M : Type u_2
M' : Type ?u.44430
N : Type ?u.44433
P : Type ?u.44436
G : Type ?u.44439
H : Type ?u.44442
R : Type ?u.44445
S : Type ?u.44448
inst✝ : Zero M
a✝¹ a'✝ : α
b✝ : M
a a' : α
b : M
a✝ : α
h : a' = a
⊢ ↑(single a b) a✝ = ↑(single a' b) a✝

tactic: rw [zero_apply, single_apply, ite_self]
state_before: case h.inr
α : Type u_1
β : Type ?u.44418
γ : Type ?u.44421
ι : Type ?u.44424
M : Type u_2
M' : Type ?u.44430
N : Type ?u.44433
P : Type ?u.44436
G : Type ?u.44439
H : Type ?u.44442
R : Type ?u.44445
S : Type ?u.44448
inst✝ : Zero M
a✝¹ a'✝ : α
b✝ : M
a a' : α
b : M
a✝ : α
h : ¬a' = a
⊢ ↑(single a 0) a✝ = ↑0 a✝
Theorem: Equiv.Perm.isCycle_swap
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rwa [swap_apply_right]
state_before: ι : Type ?u.409761
α : Type u_1
β : Type ?u.409767
f g : Perm α
x y : α
inst✝ : DecidableEq α
hxy : x ≠ y
⊢ ↑(swap x y) y ≠ y

tactic: rw [zpow_one, swap_apply_def]
state_before: ι : Type ?u.409761
α : Type u_1
β : Type ?u.409767
f g : Perm α
x y : α
inst✝ : DecidableEq α
hxy : x ≠ y
a : α
ha : (if a = x then y else if a = y then x else a) ≠ a
hya : ¬y = a
⊢ ↑(swap x y ^ 1) y = a

tactic: split_ifs at * <;> tauto
state_before: ι : Type ?u.409761
α : Type u_1
β : Type ?u.409767
f g : Perm α
x y : α
inst✝ : DecidableEq α
hxy : x ≠ y
a : α
ha : (if a = x then y else if a = y then x else a) ≠ a
hya : ¬y = a
⊢ (if y = x then y else if y = y then x else y) = a
Theorem: Finset.biUnion_singleton_eq_self
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_biUnion, mem_singleton, exists_prop, exists_eq_right']
state_before: α : Type u_1
β : Type ?u.519986
γ : Type ?u.519989
inst✝¹ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq α
x : α
⊢ x ∈ Finset.biUnion s singleton ↔ x ∈ s
Theorem: Polynomial.derivative_bit1
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp [bit1]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R[X]
⊢ ↑derivative (bit1 a) = bit0 (↑derivative a)
Theorem: bne_self_eq_false'
File: src/lean/Init/SimpLemmas.lean

tactic: simp [bne]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
⊢ (a != a) = false
Theorem: Real.sqrtTwoAddSeries_succ
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sqrtTwoAddSeries, sqrtTwoAddSeries_succ _ _, sqrtTwoAddSeries]
state_before: x✝ x : ℝ
n : ℕ
⊢ sqrtTwoAddSeries x (n + 1 + 1) = sqrtTwoAddSeries (sqrt (2 + x)) (n + 1)
Theorem: Finset.mem_insertNone
File: Mathlib/Data/Finset/Option.lean

tactic: cases h
state_before: α : Type u_1
β : Type ?u.2246
s : Finset α
a : α
h : a ∈ none
⊢ a ∈ s

tactic: simp
state_before: α : Type u_1
β : Type ?u.2246
s : Finset α
a : α
⊢ some a = none ∨ some a ∈ (map Embedding.some s).val ↔ ∀ (a_1 : α), a_1 ∈ some a → a_1 ∈ s
Theorem: Ordinal.nadd_assoc
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
state_before: a✝ b✝ c✝ : Ordinal
a b c : Ordinal
⊢ a ♯ b ♯ c = a ♯ (b ♯ c)

tactic: congr <;> ext (d hd) <;> apply nadd_assoc
state_before: a✝ b✝ c✝ : Ordinal
a b c : Ordinal
⊢ max (blsub a fun a' ha' => a' ♯ b ♯ c) (max (blsub b fun b' hb' => a ♯ b' ♯ c) (blsub c fun b' x => a ♯ b ♯ b')) =
    max (blsub a fun a' x => a' ♯ (b ♯ c))
      (max (blsub b fun a' ha' => a ♯ (a' ♯ c)) (blsub c fun b' hb' => a ♯ (b ♯ b')))

tactic: exact fun  _ _ h => nadd_le_nadd_left h a
state_before: case hf
a✝ b✝ c✝ : Ordinal
a b c : Ordinal
⊢ ∀ {i j : Ordinal}, i < b ♯ c → j < b ♯ c → i ≤ j → a ♯ i ≤ a ♯ j

tactic: exact fun  _ _ h => nadd_le_nadd_right h c
state_before: case hf
a✝ b✝ c✝ : Ordinal
a b c : Ordinal
⊢ ∀ {i j : Ordinal}, i < a ♯ b → j < a ♯ b → i ≤ j → i ♯ c ≤ j ♯ c
Theorem: GenLoop.Homotopic.diagonal
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: rcases H with ⟨H⟩
state_before: X : Type u
inst✝¹ : TopologicalSpace X
n : ℕ
x : X
f g h : GenLoop n x
inst✝ : NeZero n
H : Homotopic f g
⊢ Path.Homotopic (diagonal f) (diagonal g)

tactic: refine ⟨H.compContinuousMap _, ?_⟩
state_before: case intro
X : Type u
inst✝¹ : TopologicalSpace X
n : ℕ
x : X
f g h : GenLoop n x
inst✝ : NeZero n
H : ContinuousMap.HomotopyRel f.toContinuousMap g.toContinuousMap (Cube.boundary n)
⊢ Path.Homotopic (diagonal f) (diagonal g)

tactic: rintro t _ (rfl | rfl)
state_before: case intro
X : Type u
inst✝¹ : TopologicalSpace X
n : ℕ
x : X
f g h : GenLoop n x
inst✝ : NeZero n
H : ContinuousMap.HomotopyRel f.toContinuousMap g.toContinuousMap (Cube.boundary n)
⊢ ∀ (t x_1 : ↑I),
    x_1 ∈ {0, 1} →
      ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy
                      (ContinuousMap.constPi (Fin n))).toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(diagonal f).toContinuousMap x_1 ∧
        ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy
                      (ContinuousMap.constPi (Fin n))).toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(diagonal g).toContinuousMap x_1

tactic: exact H.prop' _ _ Cube.zero_mem_boundary
state_before: case intro.inl
X : Type u
inst✝¹ : TopologicalSpace X
n : ℕ
x : X
f g h : GenLoop n x
inst✝ : NeZero n
H : ContinuousMap.HomotopyRel f.toContinuousMap g.toContinuousMap (Cube.boundary n)
t : ↑I
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy (ContinuousMap.constPi (Fin n))).toContinuousMap
              (t, x_1))
        0 =
      ↑(diagonal f).toContinuousMap 0 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy (ContinuousMap.constPi (Fin n))).toContinuousMap
              (t, x_1))
        0 =
      ↑(diagonal g).toContinuousMap 0

tactic: exact H.prop' _ _ Cube.one_mem_boundary
state_before: case intro.inr
X : Type u
inst✝¹ : TopologicalSpace X
n : ℕ
x : X
f g h : GenLoop n x
inst✝ : NeZero n
H : ContinuousMap.HomotopyRel f.toContinuousMap g.toContinuousMap (Cube.boundary n)
t : ↑I
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy (ContinuousMap.constPi (Fin n))).toContinuousMap
              (t, x_1))
        1 =
      ↑(diagonal f).toContinuousMap 1 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              (ContinuousMap.Homotopy.compContinuousMap H.toHomotopy (ContinuousMap.constPi (Fin n))).toContinuousMap
              (t, x_1))
        1 =
      ↑(diagonal g).toContinuousMap 1
Theorem: CategoryTheory.Bicategory.whiskerRight_comp_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h = (α_ f g h).hom ≫ η ▷ (g ≫ h) ≫ (α_ f' g h).inv
Theorem: MultilinearMap.map_neg
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: rw [← MultilinearMap.map_add, add_left_neg, f.map_coord_zero i (update_same i 0 m)]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁵ : Semiring R
inst✝⁴ : (i : ι) → AddCommGroup (M₁ i)
inst✝³ : AddCommGroup M₂
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f : MultilinearMap R M₁ M₂
inst✝ : DecidableEq ι
m : (i : ι) → M₁ i
i : ι
x : M₁ i
⊢ ↑f (update m i (-x)) + ↑f (update m i x) = 0
Theorem: CategoryTheory.Limits.PushoutCocone.condition_zero
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: have w := t.ι.naturality WalkingSpan.Hom.fst
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
⊢ t.ι.app WalkingSpan.zero = f ≫ inl t

tactic: dsimp at w
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
w :
  (span f g).map fst ≫ t.ι.app WalkingSpan.left =
    t.ι.app WalkingSpan.zero ≫ ((Functor.const WalkingSpan).obj t.pt).map fst
⊢ t.ι.app WalkingSpan.zero = f ≫ inl t

tactic: simpa using w.symm
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
w : f ≫ inl t = t.ι.app WalkingSpan.zero ≫ 𝟙 t.pt
⊢ t.ι.app WalkingSpan.zero = f ≫ inl t
Theorem: algebraMap_memℓp_infty
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [Algebra.algebraMap_eq_smul_one]
state_before: α : Type ?u.798282
E : α → Type ?u.798287
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
𝕜 : Type u_3
B : I → Type u_2
inst✝³ : NormedField 𝕜
inst✝² : (i : I) → NormedRing (B i)
inst✝¹ : (i : I) → NormedAlgebra 𝕜 (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
k : 𝕜
⊢ Memℓp (↑(algebraMap 𝕜 ((i : I) → B i)) k) ⊤

tactic: exact (one_memℓp_infty.const_smul k : Memℓp (k • (1 : ∀ i, B i)) ∞)
state_before: α : Type ?u.798282
E : α → Type ?u.798287
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
I : Type u_1
𝕜 : Type u_3
B : I → Type u_2
inst✝³ : NormedField 𝕜
inst✝² : (i : I) → NormedRing (B i)
inst✝¹ : (i : I) → NormedAlgebra 𝕜 (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
k : 𝕜
⊢ Memℓp (k • 1) ⊤
Theorem: Real.hasStrictDerivAt_const_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa using (hasStrictDerivAt_const _ _).rpow (hasStrictDerivAt_id x) ha
state_before: x✝ y z a : ℝ
ha : 0 < a
x : ℝ
⊢ HasStrictDerivAt (fun x => a ^ x) (a ^ x * log a) x
Theorem: Filter.inv_mem_inv
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rwa [mem_inv, inv_preimage, inv_inv]
state_before: F : Type ?u.30467
α : Type u_1
β : Type ?u.30473
γ : Type ?u.30476
δ : Type ?u.30479
ε : Type ?u.30482
inst✝ : InvolutiveInv α
f g : Filter α
s : Set α
hs : s ∈ f
⊢ s⁻¹ ∈ f⁻¹
Theorem: PathConnectedSpace.exists_path_through_family
File: Mathlib/Topology/PathConnected.lean

tactic: have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
state_before: X : Type u_1
Y : Type ?u.695592
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.695607
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ↑γ

tactic: rcases this.exists_path_through_family p fun _i => True.intro with ⟨γ, -, h⟩
state_before: X : Type u_1
Y : Type ?u.695592
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.695607
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ↑γ

tactic: exact ⟨γ, h⟩
state_before: case intro.intro
X : Type u_1
Y : Type ?u.695592
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.695607
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
h : ∀ (i : Fin (n + 1)), p i ∈ range ↑γ
⊢ ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ range ↑γ

tactic: infer_instance
state_before: X : Type u_1
Y : Type ?u.695592
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.695607
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ PathConnectedSpace X
Theorem: Filter.tendsto_comp_val_Iic_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← map_val_Iic_atBot a, tendsto_map'_iff]
state_before: ι : Type ?u.341777
ι' : Type ?u.341780
α : Type u_1
β : Type u_2
γ : Type ?u.341789
inst✝ : SemilatticeInf α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto f atBot l

tactic: rfl
state_before: ι : Type ?u.341777
ι' : Type ?u.341780
α : Type u_1
β : Type u_2
γ : Type ?u.341789
inst✝ : SemilatticeInf α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto (f ∘ Subtype.val) atBot l
Theorem: Real.logb_nonneg_iff_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← not_lt, logb_neg_iff_of_base_lt_one b_pos b_lt_one hx, not_lt]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
⊢ 0 ≤ logb b x ↔ x ≤ 1
Theorem: Equiv.Perm.IsCycleOn.conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [← preimage_inv] at hx hy
state_before: ι : Type ?u.1643430
α : Type u_1
β : Type ?u.1643436
f g : Perm α
s t : Set α
a b x✝ y✝ : α
h : IsCycleOn f s
x : α
hx : x ∈ ↑g '' s
y : α
hy : y ∈ ↑g '' s
⊢ SameCycle (g * f * g⁻¹) x y

tactic: convert Equiv.Perm.SameCycle.conj (h.2 hx hy) (g := g) <;> rw [apply_inv_self]
state_before: ι : Type ?u.1643430
α : Type u_1
β : Type ?u.1643436
f g : Perm α
s t : Set α
a b x✝ y✝ : α
h : IsCycleOn f s
x : α
hx : x ∈ ↑g⁻¹ ⁻¹' s
y : α
hy : y ∈ ↑g⁻¹ ⁻¹' s
⊢ SameCycle (g * f * g⁻¹) x y
Theorem: Polynomial.dickson_of_two_le
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: obtain ⟨n, rfl⟩ := Nat.exists_eq_add_of_le h
state_before: R : Type u_1
S : Type ?u.68228
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
h : 2 ≤ n
⊢ dickson k a n = X * dickson k a (n - 1) - ↑C a * dickson k a (n - 2)

tactic: rw [add_comm]
state_before: case intro
R : Type u_1
S : Type ?u.68228
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
h : 2 ≤ 2 + n
⊢ dickson k a (2 + n) = X * dickson k a (2 + n - 1) - ↑C a * dickson k a (2 + n - 2)

tactic: exact dickson_add_two k a n
state_before: case intro
R : Type u_1
S : Type ?u.68228
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
n : ℕ
h : 2 ≤ 2 + n
⊢ dickson k a (n + 2) = X * dickson k a (n + 2 - 1) - ↑C a * dickson k a (n + 2 - 2)
Theorem: add_sub_div_two_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [← div_sub_div_same, sub_eq_add_neg, add_comm (b / 2), ← add_assoc, ← sub_eq_add_neg, ←
  lt_sub_iff_add_lt, sub_self_div_two, sub_self_div_two, div_lt_div_right (zero_lt_two' α)]
state_before: ι : Type ?u.185600
α : Type u_1
β : Type ?u.185606
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : a < b
⊢ a + (b - a) / 2 < b
Theorem: ContDiff.div_const
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul contDiff_const
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type ?u.2004336
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x x₀ : E
c✝ : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
𝔸 : Type ?u.2007814
𝔸' : Type ?u.2007817
ι : Type ?u.2007820
𝕜' : Type u_2
inst✝⁵ : NormedRing 𝔸
inst✝⁴ : NormedAlgebra 𝕜 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸'
inst✝¹ : NormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
c : 𝕜'
⊢ ContDiff 𝕜 n fun x => f x / c
Theorem: Con.conGen_le
File: Mathlib/GroupTheory/Congruence.lean

tactic: rw [conGen_eq]
state_before: M : Type u_1
N : Type ?u.26925
P : Type ?u.26928
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
r : M → M → Prop
c : Con M
h : ∀ (x y : M), r x y → Setoid.r x y
⊢ conGen r ≤ c

tactic: exact sInf_le h
state_before: M : Type u_1
N : Type ?u.26925
P : Type ?u.26928
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ : Con M
r : M → M → Prop
c : Con M
h : ∀ (x y : M), r x y → Setoid.r x y
⊢ sInf {s | ∀ (x y : M), r x y → ↑s x y} ≤ c
Theorem: isOpen_connectedComponent
File: Mathlib/Topology/Connected.lean

tactic: rw [← connectedComponentIn_univ]
state_before: α : Type u
β : Type v
ι : Type ?u.114625
π : ι → Type ?u.114630
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
x : α
⊢ IsOpen (connectedComponent x)

tactic: exact isOpen_univ.connectedComponentIn
state_before: α : Type u
β : Type v
ι : Type ?u.114625
π : ι → Type ?u.114630
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
x : α
⊢ IsOpen (connectedComponentIn univ x)
Theorem: nat_mul_inj'
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: simpa [w] using nat_mul_inj h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
n : ℕ
a b : R
h : ↑n * a = ↑n * b
w : n ≠ 0
⊢ a = b
Theorem: CategoryTheory.Idempotents.Karoubi.p_comm
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rw [p_comp, comp_p]
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f : Hom P Q
⊢ P.p ≫ f.f = f.f ≫ Q.p
Theorem: Int.log_zpow
File: Mathlib/Data/Int/Log.lean

tactic: obtain ⟨n, rfl | rfl⟩ := Int.eq_nat_or_neg z
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
z : ℤ
⊢ log b (↑b ^ z) = z

tactic: rw [log_of_one_le_right _ (one_le_zpow_of_nonneg _ <| Int.coe_nat_nonneg _), zpow_ofNat, ←
  Nat.cast_pow, Nat.floor_coe, Nat.log_pow hb]
state_before: case intro.inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
n : ℕ
⊢ log b (↑b ^ ↑n) = ↑n

tactic: exact_mod_cast hb.le
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
n : ℕ
⊢ 1 ≤ ↑b

tactic: rw [log_of_right_le_one _ (zpow_le_one_of_nonpos _ <| neg_nonpos.mpr (Int.coe_nat_nonneg _)),
  zpow_neg, inv_inv, zpow_ofNat, ← Nat.cast_pow, Nat.ceil_natCast, Nat.clog_pow _ _ hb]
state_before: case intro.inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
n : ℕ
⊢ log b (↑b ^ (-↑n)) = -↑n

tactic: exact_mod_cast hb.le
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
n : ℕ
⊢ 1 ≤ ↑b