tasksource/leandojo huggingface dataset:
Theorem: Nat.add_factorial_lt_factorial_add
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: cases hn
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
hn : 1 ≤ n
⊢ i + n ! < (i + n)!

tactic: exact add_factorial_succ_lt_factorial_add_succ _ hi
state_before: case step
m n i : ℕ
hi : 2 ≤ i
m✝ : ℕ
a✝ : Nat.le 1 m✝
⊢ i + (succ m✝)! < (i + succ m✝)!

tactic: rw [factorial_one]
state_before: case refl
m n i : ℕ
hi : 2 ≤ i
⊢ i + 1! < (i + 1)!

tactic: exact lt_factorial_self (succ_le_succ hi)
state_before: case refl
m n i : ℕ
hi : 2 ≤ i
⊢ i + 1 < (i + 1)!
Theorem: Filter.hasBasis_coclosedCompact
File: Mathlib/Topology/SubsetProperties.lean

tactic: simp only [Filter.coclosedCompact, iInf_and']
state_before: α : Type u
β : Type v
ι : Type ?u.51065
π : ι → Type ?u.51070
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ HasBasis (coclosedCompact α) (fun s => IsClosed s ∧ IsCompact s) compl

tactic: refine' hasBasis_biInf_principal' _ ⟨∅, isClosed_empty, isCompact_empty⟩
state_before: α : Type u
β : Type v
ι : Type ?u.51065
π : ι → Type ?u.51070
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ HasBasis (⨅ (s : Set α) (_ : IsClosed s ∧ IsCompact s), 𝓟 (sᶜ)) (fun s => IsClosed s ∧ IsCompact s) compl

tactic: rintro s ⟨hs₁, hs₂⟩ t ⟨ht₁, ht₂⟩
state_before: α : Type u
β : Type v
ι : Type ?u.51065
π : ι → Type ?u.51070
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ ∀ (i : Set α),
    IsClosed i ∧ IsCompact i →
      ∀ (j : Set α), IsClosed j ∧ IsCompact j → ∃ k, (IsClosed k ∧ IsCompact k) ∧ kᶜ ⊆ iᶜ ∧ kᶜ ⊆ jᶜ

tactic: exact ⟨s ∪ t, ⟨⟨hs₁.union ht₁, hs₂.union ht₂⟩, compl_subset_compl.2 (subset_union_left _ _),
  compl_subset_compl.2 (subset_union_right _ _)⟩⟩
state_before: case intro.intro
α : Type u
β : Type v
ι : Type ?u.51065
π : ι → Type ?u.51070
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s : Set α
hs₁ : IsClosed s
hs₂ : IsCompact s
t : Set α
ht₁ : IsClosed t
ht₂ : IsCompact t
⊢ ∃ k, (IsClosed k ∧ IsCompact k) ∧ kᶜ ⊆ sᶜ ∧ kᶜ ⊆ tᶜ
Theorem: PFun.prodMap_id_id
File: Mathlib/Data/PFun.lean

tactic: simp [eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69629
δ : Type ?u.69632
ε : Type ?u.69635
ι : Type ?u.69638
f : α →. β
x✝¹ x✝ : α × β
⊢ x✝ ∈ prodMap (PFun.id α) (PFun.id β) x✝¹ ↔ x✝ ∈ PFun.id (α × β) x✝¹
Theorem: Concept.snd_ssubset_snd_iff
File: Mathlib/Order/Concept.lean

tactic: rw [ssubset_iff_subset_not_subset, lt_iff_le_not_le, snd_subset_snd_iff, snd_subset_snd_iff]
state_before: ι : Sort ?u.9595
α : Type u_2
β : Type u_1
γ : Type ?u.9604
κ : ι → Sort ?u.9609
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
⊢ c.snd ⊂ d.snd ↔ d < c
Theorem: SimpleGraph.Walk.reverse_isTrail_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: intro h
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ IsTrail p → IsTrail (reverse p)

tactic: convert h.reverse _
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
h : IsTrail p
⊢ IsTrail (reverse p)
Theorem: MvPFunctor.comp.get_mk
File: Mathlib/Data/PFunctor/Multivariate/Basic.lean

tactic: rfl
state_before: n m : ℕ
P : MvPFunctor n
Q : Fin2 n → MvPFunctor m
α β : TypeVec m
x : Obj P fun i => Obj (Q i) α
⊢ get (mk x) = x
Theorem: MeasureTheory.L1.integral_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral, integral_eq_setToFun]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.817811
𝕜 : Type ?u.817814
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : { x // x ∈ Lp E 1 }
⊢ integral f = ∫ (a : α), ↑↑f a ∂μ

tactic: exact (L1.setToFun_eq_setToL1 (dominatedFinMeasAdditive_weightedSMul μ) f).symm
state_before: α : Type u_1
E : Type u_2
F : Type ?u.817811
𝕜 : Type ?u.817814
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : { x // x ∈ Lp E 1 }
⊢ ↑integralCLM f = setToFun μ (weightedSMul μ) (_ : DominatedFinMeasAdditive μ (weightedSMul μ) 1) fun a => ↑↑f a
Theorem: MeasureTheory.Integrable.ae_eq_of_withDensityᵥ_eq
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: refine' hf.ae_eq_of_forall_set_integral_eq f g hg fun i hi _ => _
state_before: α : Type u_2
β : Type ?u.62682
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f
hg : Integrable g
hfg : withDensityᵥ μ f = withDensityᵥ μ g
⊢ f =ᶠ[ae μ] g

tactic: rw [← withDensityᵥ_apply hf hi, hfg, withDensityᵥ_apply hg hi]
state_before: α : Type u_2
β : Type ?u.62682
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f
hg : Integrable g
hfg : withDensityᵥ μ f = withDensityᵥ μ g
i : Set α
hi : MeasurableSet i
x✝ : ↑↑μ i < ⊤
⊢ (∫ (x : α) in i, f x ∂μ) = ∫ (x : α) in i, g x ∂μ
Theorem: wittStructureInt_rename
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.1846181
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_1
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ wittStructureInt p (↑(rename f) Φ) n = ↑(rename (Prod.map f id)) (wittStructureInt p Φ n)

tactic: simp only [map_rename, map_wittStructureInt, wittStructureRat, rename_bind₁, rename_rename,
  bind₁_rename]
state_before: case a
p : ℕ
R : Type ?u.1846181
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_1
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ ↑(map (Int.castRingHom ℚ)) (wittStructureInt p (↑(rename f) Φ) n) =
    ↑(map (Int.castRingHom ℚ)) (↑(rename (Prod.map f id)) (wittStructureInt p Φ n))

tactic: rfl
state_before: case a
p : ℕ
R : Type ?u.1846181
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_1
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ ↑(bind₁ fun k => ↑(bind₁ ((fun i => ↑(rename (Prod.mk i)) (W_ ℚ k)) ∘ f)) (↑(map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n) =
    ↑(bind₁ fun i =>
          ↑(bind₁ fun i_1 => ↑(rename (Prod.map f id ∘ Prod.mk i_1)) (W_ ℚ i)) (↑(map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n)
Theorem: List.sublist_suffix_of_union
File: Mathlib/Data/List/Lattice.lean

tactic: rfl
state_before: α : Type u_1
l l₁ l₂✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₂ : List α
⊢ [] <+ []

tactic: simp only [instUnionList] at h
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : a ∈ l₁ ∪ l₂
⊢ t ++ l₂ = a :: l₁ ∪ l₂

tactic: simp only [e, instUnionList, cons_union, insert_of_mem h]
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : a ∈ List.union l₁ l₂
⊢ t ++ l₂ = a :: l₁ ∪ l₂

tactic: simp only [instUnionList] at h
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : ¬a ∈ l₁ ∪ l₂
⊢ a :: t ++ l₂ = a :: l₁ ∪ l₂

tactic: simp only [cons_append, instUnionList, cons_union, e, insert_of_not_mem h]
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : ¬a ∈ List.union l₁ l₂
⊢ a :: t ++ l₂ = a :: l₁ ∪ l₂
Theorem: Nat.even_iff_not_odd
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [not_odd_iff, even_iff]
state_before: m n : ℕ
⊢ Even n ↔ ¬Odd n
Theorem: IsGroupHom.injective_iff
File: Mathlib/Deprecated/Group.lean

tactic: rw [← hf.map_one]
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : Function.Injective f
x✝ : α
⊢ f x✝ = 1 → x✝ = 1

tactic: exact @h _ _
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : Function.Injective f
x✝ : α
⊢ f x✝ = f 1 → x✝ = 1

tactic: rwa [hf.map_div, div_eq_one]
state_before: α : Type u
β : Type v
inst✝¹ : Group α
inst✝ : Group β
f✝ : α → β
hf✝ : IsGroupHom f✝
f : α → β
hf : IsGroupHom f
h : ∀ (a : α), f a = 1 → a = 1
x y : α
hxy : f x = f y
⊢ f (x / y) = 1
Theorem: Polynomial.prime_X
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: convert prime_X_sub_C (0 : R)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ Prime X

tactic: simp
state_before: case h.e'_3
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ X = X - ↑C 0
Theorem: EuclideanDomain.dvd_div_of_mul_dvd
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
⊢ b ∣ c / a

tactic: rcases h with ⟨d, rfl⟩
state_before: case inr
R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a

tactic: refine' ⟨d, _⟩
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ b ∣ a * b * d / a

tactic: rw [mul_assoc, mul_div_cancel_left _ ha]
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ a * b * d / a = b * d

tactic: simp only [div_zero, dvd_zero]
state_before: case inl
R : Type u
inst✝ : EuclideanDomain R
b c : R
h : 0 * b ∣ c
⊢ b ∣ c / 0
Theorem: Complex.tendsto_exp_nhds_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp_rw [←comp_apply (f := exp), ← tendsto_comap_iff, comap_exp_nhds_zero, tendsto_comap_iff]
state_before: α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto (fun x => (f x).re) l atBot

tactic: rfl
state_before: α : Type u_1
l : Filter α
f : α → ℂ
⊢ Tendsto (re ∘ f) l atBot ↔ Tendsto (fun x => (f x).re) l atBot
Theorem: FractionalIdeal.mem_zero_iff
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: have x'_eq_zero : x' = 0 := x'_mem_zero
state_before: R : Type u_2
inst✝² : CommRing R
S : Submonoid R
P : Type u_1
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
x : P
x✝ : x ∈ 0
x' : R
x'_mem_zero : x' ∈ ↑0
x'_eq_x : ↑(Algebra.linearMap R P) x' = x
⊢ x = 0

tactic: simp [x'_eq_x.symm, x'_eq_zero]
state_before: R : Type u_2
inst✝² : CommRing R
S : Submonoid R
P : Type u_1
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
x : P
x✝ : x ∈ 0
x' : R
x'_mem_zero : x' ∈ ↑0
x'_eq_x : ↑(Algebra.linearMap R P) x' = x
x'_eq_zero : x' = 0
⊢ x = 0

tactic: simp [hx]
state_before: R : Type u_2
inst✝² : CommRing R
S : Submonoid R
P : Type u_1
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
x : P
hx : x = 0
⊢ ↑(Algebra.linearMap R P) 0 = x
Theorem: mul_le_iff_le_one_left'
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [one_mul]
state_before: α : Type u_1
β : Type ?u.19428
inst✝³ : MulOneClass α
inst✝² : LE α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a * b ≤ b ↔ a * b ≤ 1 * b
Theorem: DirectSum.equivCongrLeft_apply
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: exact Dfinsupp.comapDomain'_apply _ h.right_inv _ _
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
κ : Type u_1
h : ι ≃ κ
f : ⨁ (i : ι), β i
k : κ
⊢ ↑(↑(equivCongrLeft h) f) k = ↑f (↑h.symm k)
Theorem: DirectSum.mul_comm
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: suffices mulHom A = (mulHom A).flip by
  rw [← mulHom_apply, this, AddMonoidHom.flip_apply, mulHom_apply]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
⊢ a * b = b * a

tactic: apply addHom_ext
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
⊢ mulHom A = AddMonoidHom.flip (mulHom A)

tactic: intro ai ax
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
⊢ ∀ (i : ι) (y : A i),
    ↑(mulHom A) (↑(of (fun i => A i) i) y) = ↑(AddMonoidHom.flip (mulHom A)) (↑(of (fun i => A i) i) y)

tactic: apply addHom_ext
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
ai : ι
ax : A ai
⊢ ↑(mulHom A) (↑(of (fun i => A i) ai) ax) = ↑(AddMonoidHom.flip (mulHom A)) (↑(of (fun i => A i) ai) ax)

tactic: intro bi bx
state_before: case H.H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
ai : ι
ax : A ai
⊢ ∀ (i : ι) (y : A i),
    ↑(↑(mulHom A) (↑(of (fun i => A i) ai) ax)) (↑(of (fun i => A i) i) y) =
      ↑(↑(AddMonoidHom.flip (mulHom A)) (↑(of (fun i => A i) ai) ax)) (↑(of (fun i => A i) i) y)

tactic: rw [AddMonoidHom.flip_apply, mulHom_of_of, mulHom_of_of]
state_before: case H.H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
ai : ι
ax : A ai
bi : ι
bx : A bi
⊢ ↑(↑(mulHom A) (↑(of (fun i => A i) ai) ax)) (↑(of (fun i => A i) bi) bx) =
    ↑(↑(AddMonoidHom.flip (mulHom A)) (↑(of (fun i => A i) ai) ax)) (↑(of (fun i => A i) bi) bx)

tactic: exact of_eq_of_gradedMonoid_eq (GCommSemiring.mul_comm ⟨ai, ax⟩ ⟨bi, bx⟩)
state_before: case H.H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
ai : ι
ax : A ai
bi : ι
bx : A bi
⊢ ↑(of A (ai + bi)) (GradedMonoid.GMul.mul ax bx) = ↑(of A (bi + ai)) (GradedMonoid.GMul.mul bx ax)

tactic: rw [← mulHom_apply, this, AddMonoidHom.flip_apply, mulHom_apply]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddCommMonoid ι
inst✝ : GCommSemiring A
a b : ⨁ (i : ι), A i
this : mulHom A = AddMonoidHom.flip (mulHom A)
⊢ a * b = b * a
Theorem: InnerProductGeometry.angle_self_neg_of_nonzero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle_neg_right, angle_self hx, sub_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
hx : x ≠ 0
⊢ angle x (-x) = π
Theorem: Finset.image₂_singleton_left
File: Mathlib/Data/Finset/NAry.lean

tactic: simp
state_before: α : Type u_2
α' : Type ?u.26477
β : Type u_3
β' : Type ?u.26483
γ : Type u_1
γ' : Type ?u.26489
δ : Type ?u.26492
δ' : Type ?u.26495
ε : Type ?u.26498
ε' : Type ?u.26501
ζ : Type ?u.26504
ζ' : Type ?u.26507
ν : Type ?u.26510
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c x : γ
⊢ x ∈ image₂ f {a} t ↔ x ∈ image (fun b => f a b) t
Theorem: mem_omegaLimit_iff_frequently₂
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: simp_rw [mem_omegaLimit_iff_frequently, image_inter_nonempty_iff]
state_before: τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.30321
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ y ∈ ω f ϕ s ↔ ∀ (n : Set β), n ∈ 𝓝 y → ∃ᶠ (t : τ) in f, Set.Nonempty (ϕ t '' s ∩ n)
Theorem: Real.logb_pos_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← @logb_one b]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ 0 < logb b x ↔ 1 < x

tactic: rw [logb_lt_logb_iff hb zero_lt_one hx]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b 1 < logb b x ↔ 1 < x
Theorem: SimpleGraph.Walk.concat_ne_nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp [concat]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
h : Adj G v u
⊢ concat p h ≠ nil
Theorem: Submodule.finrank_quotient_le
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simpa only [Cardinal.toNat_lift] using
  toNat_le_of_le_of_lt_aleph0 (rank_lt_aleph0 _ _)
    ((Submodule.mkQ s).rank_le_of_surjective (surjective_quot_mk _))
state_before: R : Type u
M : Type v
N : Type w
inst✝⁶ : Ring R
inst✝⁵ : StrongRankCondition R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R M
s : Submodule R M
⊢ finrank R (M ⧸ s) ≤ finrank R M
Theorem: mem_rootsOfUnity'
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [mem_rootsOfUnity]
state_before: M : Type u_1
N : Type ?u.155571
G : Type ?u.155574
R : Type ?u.155577
S : Type ?u.155580
F : Type ?u.155583
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l k : ℕ+
ζ : Mˣ
⊢ ζ ∈ rootsOfUnity k M ↔ ↑ζ ^ ↑k = 1

tactic: norm_cast
state_before: M : Type u_1
N : Type ?u.155571
G : Type ?u.155574
R : Type ?u.155577
S : Type ?u.155580
F : Type ?u.155583
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k✝ l k : ℕ+
ζ : Mˣ
⊢ ζ ^ ↑k = 1 ↔ ↑ζ ^ ↑k = 1
Theorem: Interval.coe_iInf₂
File: Mathlib/Order/Interval.lean

tactic: simp_rw [coe_iInf]
state_before: α : Type u_1
β : Type ?u.68647
γ : Type ?u.68650
δ : Type ?u.68653
ι : Sort u_2
κ : ι → Sort u_3
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
f : (i : ι) → κ i → Interval α
⊢ ↑(⨅ (i : ι) (j : κ i), f i j) = ⋂ (i : ι) (j : κ i), ↑(f i j)
Theorem: isPiSystem_Icc_mem
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: exact Icc_inter_Icc
state_before: α : Type u_1
ι : Sort ?u.19636
ι' : Sort ?u.19639
inst✝ : LinearOrder α
s t : Set α
⊢ ∀ {a₁ b₁ a₂ b₂ : α}, Icc a₁ b₁ ∩ Icc a₂ b₂ = Icc (max a₁ a₂) (min b₁ b₂)
Theorem: List.sum_take_map_length_splitWrtComposition
File: Mathlib/Combinatorics/Composition.lean

tactic: congr
state_before: n : ℕ
α : Type u_1
l : List α
c : Composition (length l)
i : ℕ
⊢ sum (take i (map length (splitWrtComposition l c))) = Composition.sizeUpTo c i

tactic: exact map_length_splitWrtComposition l c
state_before: case e_a.e_a
n : ℕ
α : Type u_1
l : List α
c : Composition (length l)
i : ℕ
⊢ map length (splitWrtComposition l c) = c.blocks
Theorem: Polynomial.C_mem_lifts
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, map_C, Set.mem_univ, Subsemiring.coe_top, eq_self_iff_true,
  and_self_iff]
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f✝ f : R →+* S
r : R
⊢ ↑(mapRingHom f) (↑C r) = ↑C (↑f r)
Theorem: Euclidean.nhds_basis_closedBall
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [toEuclidean.toHomeomorph.nhds_eq_comap x]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ Filter.HasBasis (𝓝 x) (fun r => 0 < r) (closedBall x)

tactic: exact Metric.nhds_basis_closedBall.comap _
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ Filter.HasBasis
    (Filter.comap (↑(ContinuousLinearEquiv.toHomeomorph toEuclidean))
      (𝓝 (↑(ContinuousLinearEquiv.toHomeomorph toEuclidean) x)))
    (fun r => 0 < r) (closedBall x)
Theorem: Real.Angle.toReal_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [toReal_coe_eq_self_iff]
state_before: ⊢ toReal ↑π = π

tactic: exact ⟨Left.neg_lt_self Real.pi_pos, le_refl _⟩
state_before: ⊢ -π < π ∧ π ≤ π
Theorem: directedOn_iff_directed
File: Mathlib/Order/Directed.lean

tactic: simp [Directed, DirectedOn]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
s : Set α
⊢ DirectedOn r s ↔ Directed r Subtype.val

tactic: refine' ball_congr fun x _ => by simp [And.comm, and_assoc]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
s : Set α
⊢ (∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → ∃ z, z ∈ s ∧ r x z ∧ r y z) ↔
    ∀ (a : α), a ∈ s → ∀ (a_1 : α), a_1 ∈ s → ∃ a_2, r a a_2 ∧ a_2 ∈ s ∧ r a_1 a_2

tactic: simp [And.comm, and_assoc]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
s : Set α
x : α
x✝ : x ∈ s
⊢ (∀ (y : α), y ∈ s → ∃ z, z ∈ s ∧ r x z ∧ r y z) ↔ ∀ (a : α), a ∈ s → ∃ a_1, r x a_1 ∧ a_1 ∈ s ∧ r a a_1
Theorem: SimpleGraph.Walk.reverseAux_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons h _ ih => simp [ih (cons (G.symm h) q)]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x : V
p : Walk G u v
q : Walk G u w
r : Walk G w x
⊢ append (Walk.reverseAux p q) r = Walk.reverseAux p (append q r)

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x : V
r : Walk G w x
u✝ : V
q : Walk G u✝ w
⊢ append (Walk.reverseAux nil q) r = Walk.reverseAux nil (append q r)

tactic: simp [ih (cons (G.symm h) q)]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x : V
r : Walk G w x
u✝ v✝ w✝ : V
h : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (q : Walk G v✝ w), append (Walk.reverseAux p✝ q) r = Walk.reverseAux p✝ (append q r)
q : Walk G u✝ w
⊢ append (Walk.reverseAux (cons h p✝) q) r = Walk.reverseAux (cons h p✝) (append q r)
Theorem: Real.cosh_eq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [cosh, exp, exp, Complex.ofReal_neg, Complex.cosh, mul_two, ← Complex.add_re, ← mul_two,
  div_mul_cancel _ (two_ne_zero' ℂ), Complex.add_re]
state_before: x✝ y x : ℝ
⊢ cosh x * 2 = exp x + exp (-x)
Theorem: List.chain'_append
File: Mathlib/Data/List/Chain.lean

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
l : List α
⊢ Chain' R ([] ++ l) ↔ Chain' R [] ∧ Chain' R l ∧ ∀ (x : α), x ∈ getLast? [] → ∀ (y : α), y ∈ head? l → R x y

tactic: simp [chain'_cons', and_comm]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b a : α
l : List α
⊢ Chain' R ([a] ++ l) ↔ Chain' R [a] ∧ Chain' R l ∧ ∀ (x : α), x ∈ getLast? [a] → ∀ (y : α), y ∈ head? l → R x y

tactic: rw [cons_append, cons_append, chain'_cons, chain'_cons, ← cons_append, chain'_append,
  and_assoc]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ Chain' R (a :: b :: l₁ ++ l₂) ↔
    Chain' R (a :: b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ getLast? (a :: b :: l₁) → ∀ (y : α), y ∈ head? l₂ → R x y

tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ (R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ getLast? (b :: l₁) → ∀ (y : α), y ∈ head? l₂ → R x y) ↔
    R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ getLast? (a :: b :: l₁) → ∀ (y : α), y ∈ head? l₂ → R x y