tasksource/leandojo huggingface dataset:
Theorem: mem_nhds_induced
File: Mathlib/Topology/Order.lean

tactic: letI := T.induced f
state_before: α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
⊢ s ∈ 𝓝 a ↔ ∃ u, u ∈ 𝓝 (f a) ∧ f ⁻¹' u ⊆ s

tactic: simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
state_before: α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ s ∈ 𝓝 a ↔ ∃ u, u ∈ 𝓝 (f a) ∧ f ⁻¹' u ⊆ s

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t, t ⊆ s ∧ (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) ↔ ∃ u, (∃ t, t ⊆ u ∧ IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

tactic: rintro ⟨u, usub, ⟨v, openv, rfl⟩, au⟩
state_before: case mp
α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t, t ⊆ s ∧ (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) → ∃ u, (∃ t, t ⊆ u ∧ IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

tactic: exact ⟨v, ⟨v, Subset.rfl, openv, au⟩, usub⟩
state_before: case mp.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
v : Set α
openv : IsOpen v
usub : f ⁻¹' v ⊆ s
au : a ∈ f ⁻¹' v
⊢ ∃ u, (∃ t, t ⊆ u ∧ IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

tactic: rintro ⟨u, ⟨v, vsubu, openv, amem⟩, finvsub⟩
state_before: case mpr
α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ u, (∃ t, t ⊆ u ∧ IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s) → ∃ t, t ⊆ s ∧ (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t

tactic: exact ⟨f ⁻¹' v, (Set.preimage_mono vsubu).trans finvsub, ⟨⟨v, openv, rfl⟩, amem⟩⟩
state_before: case mpr.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type ?u.43330
f✝ : α → β
ι : Sort ?u.43337
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
u : Set α
finvsub : f ⁻¹' u ⊆ s
v : Set α
vsubu : v ⊆ u
openv : IsOpen v
amem : f a ∈ v
⊢ ∃ t, t ⊆ s ∧ (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t
Theorem: Polynomial.X_pow_sub_one_separable_iff
File: Mathlib/FieldTheory/Separable.lean

tactic: refine' ⟨_, fun h => separable_X_pow_sub_C_unit 1 (IsUnit.mk0 (↑n) h)⟩
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
n : ℕ
⊢ Separable (X ^ n - 1) ↔ ↑n ≠ 0

tactic: rw [separable_def', derivative_sub, derivative_X_pow, derivative_one, sub_zero]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
n : ℕ
⊢ Separable (X ^ n - 1) → ↑n ≠ 0

tactic: rintro (h : IsCoprime _ _) hn'
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
n : ℕ
⊢ (∃ a b, a * (X ^ n - 1) + b * (↑C ↑n * X ^ (n - 1)) = 1) → ↑n ≠ 0

tactic: rw [hn', C_0, MulZeroClass.zero_mul, isCoprime_zero_right] at h
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
n : ℕ
h : IsCoprime (X ^ n - 1) (↑C ↑n * X ^ (n - 1))
hn' : ↑n = 0
⊢ False

tactic: exact not_isUnit_X_pow_sub_one F n h
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
n : ℕ
h : IsUnit (X ^ n - 1)
hn' : ↑n = 0
⊢ False
Theorem: Polynomial.derivative_X
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
⊢ ↑(monomial (1 - 1)) (1 * ↑1) = 1
Theorem: Algebra.FiniteType.mvPolynomial
File: Mathlib/RingTheory/FiniteType.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u_2
A : Type u
B : Type ?u.10616
M : Type ?u.10619
N : Type ?u.10622
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Algebra R A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
⊢ FiniteType R (MvPolynomial ι R)

tactic: exact
  ⟨⟨Finset.univ.image MvPolynomial.X, by
      rw [Finset.coe_image, Finset.coe_univ, Set.image_univ]
      exact MvPolynomial.adjoin_range_X⟩⟩
state_before: case intro
R : Type u_2
A : Type u
B : Type ?u.10616
M : Type ?u.10619
N : Type ?u.10622
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Algebra R A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
val✝ : Fintype ι
⊢ FiniteType R (MvPolynomial ι R)

tactic: rw [Finset.coe_image, Finset.coe_univ, Set.image_univ]
state_before: R : Type u_2
A : Type u
B : Type ?u.10616
M : Type ?u.10619
N : Type ?u.10622
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Algebra R A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
val✝ : Fintype ι
⊢ adjoin R ↑(Finset.image MvPolynomial.X Finset.univ) = ⊤

tactic: exact MvPolynomial.adjoin_range_X
state_before: R : Type u_2
A : Type u
B : Type ?u.10616
M : Type ?u.10619
N : Type ?u.10622
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Algebra R A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra R B
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
val✝ : Fintype ι
⊢ adjoin R (Set.range MvPolynomial.X) = ⊤
Theorem: dist_one_right
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_eq_norm_div, div_one]
state_before: 𝓕 : Type ?u.49802
𝕜 : Type ?u.49805
α : Type ?u.49808
ι : Type ?u.49811
κ : Type ?u.49814
E : Type u_1
F : Type ?u.49820
G : Type ?u.49823
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ dist a 1 = ‖a‖
Theorem: wbtw_smul_vadd_smul_vadd_of_nonneg_of_nonpos
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [wbtw_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.563494
P : Type u_3
P' : Type ?u.563500
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : r₂ ≤ 0
⊢ Wbtw R (r₁ • v +ᵥ x) x (r₂ • v +ᵥ x)

tactic: exact wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg x v hr₂ hr₁
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.563494
P : Type u_3
P' : Type ?u.563500
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : r₂ ≤ 0
⊢ Wbtw R (r₂ • v +ᵥ x) x (r₁ • v +ᵥ x)
Theorem: Filter.ZeroAtFilter.boundedAtFilter
File: Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean

tactic: rw [ZeroAtFilter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
state_before: α : Type u_2
β : Type u_1
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : ZeroAtFilter l f
⊢ BoundedAtFilter l f

tactic: exact hf.isBigO
state_before: α : Type u_2
β : Type u_1
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : f =o[l] fun _x => 1
⊢ BoundedAtFilter l f
Theorem: BoxIntegral.Box.volume_apply
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

tactic: rw [Measure.toBoxAdditive_apply, coe_eq_pi, Real.volume_pi_Ioc_toReal I.lower_le_upper]
state_before: ι : Type u_1
inst✝ : Fintype ι
I : Box ι
⊢ ↑(Measure.toBoxAdditive volume) I = ∏ i : ι, (upper I i - lower I i)
Theorem: Matrix.adjugate_diagonal
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext i j
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
⊢ adjugate (diagonal v) = diagonal fun i => ∏ j in Finset.erase univ i, v j

tactic: simp only [adjugate_def, cramer_apply, diagonal_transpose, of_apply]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
⊢ adjugate (diagonal v) i j = diagonal (fun i => ∏ j in Finset.erase univ i, v j) i j

tactic: obtain rfl | hij := eq_or_ne i j
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
⊢ det (updateColumn (diagonal v) j (Pi.single i 1)) = diagonal (fun i => ∏ j in Finset.erase univ i, v j) i j

tactic: rw [diagonal_apply_eq, diagonal_updateColumn_single, det_diagonal,
  prod_update_of_mem (Finset.mem_univ _), sdiff_singleton_eq_erase, one_mul]
state_before: case a.h.inl
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i : n
⊢ det (updateColumn (diagonal v) i (Pi.single i 1)) = diagonal (fun i => ∏ j in Finset.erase univ i, v j) i i

tactic: rw [diagonal_apply_ne _ hij]
state_before: case a.h.inr
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
hij : i ≠ j
⊢ det (updateColumn (diagonal v) j (Pi.single i 1)) = diagonal (fun i => ∏ j in Finset.erase univ i, v j) i j

tactic: refine' det_eq_zero_of_row_eq_zero j fun k => _
state_before: case a.h.inr
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
hij : i ≠ j
⊢ det (updateColumn (diagonal v) j (Pi.single i 1)) = 0

tactic: obtain rfl | hjk := eq_or_ne k j
state_before: case a.h.inr
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
hij : i ≠ j
k : n
⊢ updateColumn (diagonal v) j (Pi.single i 1) j k = 0

tactic: rw [updateColumn_self, Pi.single_eq_of_ne' hij]
state_before: case a.h.inr.inl
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i k : n
hij : i ≠ k
⊢ updateColumn (diagonal v) k (Pi.single i 1) k k = 0

tactic: rw [updateColumn_ne hjk, diagonal_apply_ne' _ hjk]
state_before: case a.h.inr.inr
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
v : n → α
i j : n
hij : i ≠ j
k : n
hjk : k ≠ j
⊢ updateColumn (diagonal v) j (Pi.single i 1) j k = 0
Theorem: Finset.affineCombination_indicator_subset
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [affineCombination_apply, affineCombination_apply,
  weightedVSubOfPoint_indicator_subset _ _ _ h]
state_before: k : Type u_3
V : Type u_4
P : Type u_2
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.308407
s₂✝ : Finset ι₂
w : ι → k
p : ι → P
s₁ s₂ : Finset ι
h : s₁ ⊆ s₂
⊢ ↑(affineCombination k s₁ p) w = ↑(affineCombination k s₂ p) (Set.indicator (↑s₁) w)
Theorem: Ctop.ofEquiv_val
File: Mathlib/Data/Analysis/Topology.lean

tactic: cases F
state_before: α : Type u_3
β : Type ?u.5046
σ : Type u_1
τ : Type u_2
F✝ : Ctop α σ
E : σ ≃ τ
F : Ctop α σ
a : τ
⊢ f (ofEquiv E F) a = f F (↑E.symm a)

tactic: rfl
state_before: case mk
α : Type u_3
β : Type ?u.5046
σ : Type u_1
τ : Type u_2
F : Ctop α σ
E : σ ≃ τ
a : τ
f✝ : σ → Set α
top✝ : α → σ
top_mem✝ : ∀ (x : α), x ∈ f✝ (top✝ x)
inter✝ : (a b : σ) → (x : α) → x ∈ f✝ a ∩ f✝ b → σ
inter_mem✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), x ∈ f✝ (inter✝ a b x h)
inter_sub✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), f✝ (inter✝ a b x h) ⊆ f✝ a ∩ f✝ b
⊢ f
      (ofEquiv E
        { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝,
          inter_sub := inter_sub✝ })
      a =
    f { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝, inter_sub := inter_sub✝ }
      (↑E.symm a)
Theorem: Submonoid.mul_leftInvEquiv_symm
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: convert S.leftInvEquiv_mul hS ((S.leftInvEquiv hS).symm x)
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ S }
⊢ ↑x * ↑(↑(MulEquiv.symm (leftInvEquiv S hS)) x) = 1

tactic: simp
state_before: case h.e'_2.h.e'_5.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ S }
⊢ x = ↑(leftInvEquiv S hS) (↑(MulEquiv.symm (leftInvEquiv S hS)) x)
Theorem: StateT.run_seqLeft
File: src/lean/Init/Control/Lawful.lean

tactic: show (x >>= fun a => y >>= fun _ => pure a).run s = _
state_before: m : Type u → Type u_1
α β σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : StateT σ m α
y : StateT σ m β
s : σ
⊢ run (SeqLeft.seqLeft x fun x => y) s = do
    let p ← run x s
    let p' ← run y p.snd
    pure (p.fst, p'.snd)

tactic: simp
state_before: m : Type u → Type u_1
α β σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : StateT σ m α
y : StateT σ m β
s : σ
⊢ run
      (do
        let a ← x
        let _ ← y
        pure a)
      s =
    do
    let p ← run x s
    let p' ← run y p.snd
    pure (p.fst, p'.snd)
Theorem: Matrix.toLin_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [← LinearMap.toMatrix_id v₁, Matrix.toLin_toMatrix]
state_before: R : Type u_3
inst✝⁷ : CommSemiring R
l : Type ?u.1778621
m : Type ?u.1778624
n : Type u_2
inst✝⁶ : Fintype n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
M₁ : Type u_1
M₂ : Type ?u.1778648
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
⊢ ↑(toLin v₁ v₁) 1 = LinearMap.id
Theorem: Basis.coe_mkFinCons
File: Mathlib/LinearAlgebra/Basis.lean

tactic: unfold mkFinCons
state_before: ι : Type ?u.995828
ι' : Type ?u.995831
R : Type u_1
R₂ : Type ?u.995837
K : Type ?u.995840
M : Type u_2
M' : Type ?u.995846
M'' : Type ?u.995849
V : Type u
V' : Type ?u.995854
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R { x // x ∈ N }
hli : ∀ (c : R) (x : M), x ∈ N → c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ↑(mkFinCons y b hli hsp) = Fin.cons y (Subtype.val ∘ ↑b)

tactic: exact coe_mk (v := Fin.cons y (N.subtype ∘ b)) _ _
state_before: ι : Type ?u.995828
ι' : Type ?u.995831
R : Type u_1
R₂ : Type ?u.995837
K : Type ?u.995840
M : Type u_2
M' : Type ?u.995846
M'' : Type ?u.995849
V : Type u
V' : Type ?u.995854
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R { x // x ∈ N }
hli : ∀ (c : R) (x : M), x ∈ N → c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ↑(let_fun span_b := (_ : span R (Set.range (↑(Submodule.subtype N) ∘ ↑b)) = N);
      Basis.mk (_ : LinearIndependent R (Fin.cons y (↑(Submodule.subtype N) ∘ ↑b)))
        (_ : ∀ (x : M), x ∈ ⊤ → x ∈ span R (Set.range (Fin.cons y (↑(Submodule.subtype N) ∘ ↑b))))) =
    Fin.cons y (Subtype.val ∘ ↑b)
Theorem: Inducing.continuousAt_iff'
File: Mathlib/Topology/Maps.lean

tactic: simp_rw [ContinuousAt, Filter.Tendsto, ← hf.map_nhds_of_mem _ h, Filter.map_map, comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.4384
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → γ
hf : Inducing f
x : α
h : range f ∈ 𝓝 (f x)
⊢ ContinuousAt (g ∘ f) x ↔ ContinuousAt g (f x)
Theorem: AList.union_assoc
File: Mathlib/Data/List/AList.lean

tactic: simp [not_or, or_assoc, and_or_left, and_assoc]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁ s₂ s₃ : AList β
⊢ ∀ (x : α) (y : β x), y ∈ dlookup x (s₁ ∪ s₂ ∪ s₃).entries ↔ y ∈ dlookup x (s₁ ∪ (s₂ ∪ s₃)).entries
Theorem: orderOf_pow''
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: unfold orderOf
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : IsOfFinOrder x
⊢ orderOf (x ^ n) = orderOf x / gcd (orderOf x) n

tactic: rw [← minimalPeriod_iterate_eq_div_gcd' h, mul_left_iterate]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / gcd (minimalPeriod (fun x_1 => x * x_1) 1) n
Theorem: Filter.pi_inf_principal_univ_pi_neBot
File: Mathlib/Order/Filter/Pi.lean

tactic: simp [neBot_iff]
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
⊢ NeBot (pi f ⊓ 𝓟 (Set.pi univ s)) ↔ ∀ (i : ι), NeBot (f i ⊓ 𝓟 (s i))
Theorem: Turing.ListBlank.append_assoc
File: Mathlib/Computability/TuringMachine.lean

tactic: refine' l₃.inductionOn fun l ↦ _
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
l₃ : ListBlank Γ
⊢ append (l₁ ++ l₂) l₃ = append l₁ (append l₂ l₃)

tactic: suffices append (l₁ ++ l₂) (mk l) = append l₁ (append l₂ (mk l)) by exact this
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
l₃ : ListBlank Γ
l : List Γ
⊢ append (l₁ ++ l₂) (Quotient.mk (BlankRel.setoid Γ) l) = append l₁ (append l₂ (Quotient.mk (BlankRel.setoid Γ) l))

tactic: simp only [ListBlank.append_mk, List.append_assoc]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
l₃ : ListBlank Γ
l : List Γ
⊢ append (l₁ ++ l₂) (mk l) = append l₁ (append l₂ (mk l))

tactic: exact this
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ : List Γ
l₃ : ListBlank Γ
l : List Γ
this : append (l₁ ++ l₂) (mk l) = append l₁ (append l₂ (mk l))
⊢ append (l₁ ++ l₂) (Quotient.mk (BlankRel.setoid Γ) l) = append l₁ (append l₂ (Quotient.mk (BlankRel.setoid Γ) l))
Theorem: Filter.Tendsto.atBot_mul_neg_const'
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa only [mul_neg, tendsto_neg_atBot_iff] using hf.atBot_mul_const' (neg_pos.2 hr)
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedRing R
inst✝ : Archimedean R
hr : r < 0
hf : Tendsto f l atBot
⊢ Tendsto (fun x => f x * r) l atTop
Theorem: Ordinal.lt_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp_rw [← Cardinal.ord_aleph0, Cardinal.lt_ord, lt_aleph0, card_eq_nat]
state_before: o : Ordinal
⊢ o < ω ↔ ∃ n, o = ↑n
Theorem: Set.mem_image2_iff
File: Mathlib/Data/Set/NAry.lean

tactic: rintro ⟨a', b', ha', hb', h⟩
state_before: α : Type u_1
α' : Type ?u.898
β : Type u_2
β' : Type ?u.904
γ : Type u_3
γ' : Type ?u.910
δ : Type ?u.913
δ' : Type ?u.916
ε : Type ?u.919
ε' : Type ?u.922
ζ : Type ?u.925
ζ' : Type ?u.928
ν : Type ?u.931
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
hf : Injective2 f
⊢ f a b ∈ image2 f s t → a ∈ s ∧ b ∈ t

tactic: rcases hf h with ⟨rfl, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
α' : Type ?u.898
β : Type u_2
β' : Type ?u.904
γ : Type u_3
γ' : Type ?u.910
δ : Type ?u.913
δ' : Type ?u.916
ε : Type ?u.919
ε' : Type ?u.922
ζ : Type ?u.925
ζ' : Type ?u.928
ν : Type ?u.931
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a'✝ : α
b b'✝ : β
c c' : γ
d d' : δ
hf : Injective2 f
a' : α
b' : β
ha' : a' ∈ s
hb' : b' ∈ t
h : f a' b' = f a b
⊢ a ∈ s ∧ b ∈ t

tactic: exact ⟨ha', hb'⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_1
α' : Type ?u.898
β : Type u_2
β' : Type ?u.904
γ : Type u_3
γ' : Type ?u.910
δ : Type ?u.913
δ' : Type ?u.916
ε : Type ?u.919
ε' : Type ?u.922
ζ : Type ?u.925
ζ' : Type ?u.928
ν : Type ?u.931
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a'✝ : α
b'✝ : β
c c' : γ
d d' : δ
hf : Injective2 f
a' : α
b' : β
ha' : a' ∈ s
hb' : b' ∈ t
h : f a' b' = f a' b'
⊢ a' ∈ s ∧ b' ∈ t
Theorem: MonoidAlgebra.support_gen_of_gen
File: Mathlib/RingTheory/FiniteType.lean

tactic: refine' le_antisymm le_top _
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support) = ⊤

tactic: rw [← hS, adjoin_le_iff]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⊤ ≤ adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support)

tactic: intro f hf
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ S ⊆ ↑(adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support))

tactic: have hincl : (of R M '' f.support) ⊆
    Set.iUnion fun (g : MonoidAlgebra R M)
      => Set.iUnion fun (_ : g ∈ S) => (of R M '' g.support) := by
  intro s hs
  exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
f : MonoidAlgebra R M
hf : f ∈ S
⊢ f ∈ ↑(adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support))

tactic: exact adjoin_mono hincl (mem_adjoin_support f)
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
f : MonoidAlgebra R M
hf : f ∈ S
hincl : ↑(of R M) '' ↑f.support ⊆ ⋃ (g : MonoidAlgebra R M) (_ : g ∈ S), ↑(of R M) '' ↑g.support
⊢ f ∈ ↑(adjoin R (⋃ (f : MonoidAlgebra R M) (_ : f ∈ S), ↑(of R M) '' ↑f.support))

tactic: intro s hs
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
f : MonoidAlgebra R M
hf : f ∈ S
⊢ ↑(of R M) '' ↑f.support ⊆ ⋃ (g : MonoidAlgebra R M) (_ : g ∈ S), ↑(of R M) '' ↑g.support

tactic: exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Monoid M
S : Set (MonoidAlgebra R M)
hS : adjoin R S = ⊤
f : MonoidAlgebra R M
hf : f ∈ S
s : MonoidAlgebra R M
hs : s ∈ ↑(of R M) '' ↑f.support
⊢ s ∈ ⋃ (g : MonoidAlgebra R M) (_ : g ∈ S), ↑(of R M) '' ↑g.support
Theorem: Cardinal.denumerable_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: cases' Quotient.exact h with f
state_before: α✝ β α : Type u
h : (#α) = ℵ₀
⊢ Nonempty (Denumerable α)

tactic: exact ⟨Denumerable.mk' <| f.trans Equiv.ulift⟩
state_before: case intro
α✝ β α : Type u
h : (#α) = ℵ₀
f : α ≃ ULift ℕ
⊢ Nonempty (Denumerable α)
Theorem: Cubic.C_mul_prod_X_sub_C_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: simp only [toPoly, C_neg, C_add, C_mul]
state_before: R : Type ?u.90291
S : Type u_1
F : Type ?u.90297
K : Type ?u.90300
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ ↑C w * (X - ↑C x) * (X - ↑C y) * (X - ↑C z) =
    toPoly { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }

tactic: ring1
state_before: R : Type ?u.90291
S : Type u_1
F : Type ?u.90297
K : Type ?u.90300
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ ↑C w * (X - ↑C x) * (X - ↑C y) * (X - ↑C z) =
    ↑C w * X ^ 3 + ↑C w * -(↑C x + ↑C y + ↑C z) * X ^ 2 + ↑C w * (↑C x * ↑C y + ↑C x * ↑C z + ↑C y * ↑C z) * X +
      ↑C w * -(↑C x * ↑C y * ↑C z)
Theorem: Equiv.swap_mul_self_mul
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: rw [← mul_assoc, swap_mul_self, one_mul]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ swap i j * (swap i j * σ) = σ
Theorem: List.foldrM_cons
File: Std/Data/List/Init/Lemmas.lean

tactic: simp only [foldrM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
a : α
l : List α
f : α → β → m β
b : β
⊢ foldrM f b (a :: l) = foldrM f b l >>= f a

tactic: induction l <;> simp_all
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
a : α
l : List α
f : α → β → m β
b : β
⊢ List.foldlM (fun s a => f a s) b (reverse (a :: l)) = List.foldlM (fun s a => f a s) b (reverse l) >>= f a