tasksource/leandojo huggingface dataset:
Theorem: inseparable_iff_forall_closed
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [inseparable_iff_specializes_and, specializes_iff_forall_closed, ← forall_and, ←
  iff_def]
state_before: X : Type u_1
Y : Type ?u.30940
Z : Type ?u.30943
α : Type ?u.30946
ι : Type ?u.30949
π : ι → Type ?u.30954
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
⊢ (x ~ᵢ y) ↔ ∀ (s : Set X), IsClosed s → (x ∈ s ↔ y ∈ s)
Theorem: Polynomial.comp_C
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp [comp, (C : R →+* _).map_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp p (↑C a) = ↑C (eval a p)
Theorem: TopCat.embedding_prod_map
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: haveI := (TopCat.mono_iff_injective _).mpr hf.inj
state_before: J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ X
g : Y ⟶ Z
hf : Embedding ((forget TopCat).map f)
hg : Embedding ((forget TopCat).map g)
⊢ Function.Injective ((forget TopCat).map (prod.map f g))

tactic: haveI := (TopCat.mono_iff_injective _).mpr hg.inj
state_before: J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ X
g : Y ⟶ Z
hf : Embedding ((forget TopCat).map f)
hg : Embedding ((forget TopCat).map g)
this : Mono f
⊢ Function.Injective ((forget TopCat).map (prod.map f g))

tactic: exact (TopCat.mono_iff_injective _).mp inferInstance
state_before: J : Type v
inst✝ : SmallCategory J
W X Y Z : TopCat
f : W ⟶ X
g : Y ⟶ Z
hf : Embedding ((forget TopCat).map f)
hg : Embedding ((forget TopCat).map g)
this✝ : Mono f
this : Mono g
⊢ Function.Injective ((forget TopCat).map (prod.map f g))
Theorem: Dfinsupp.update_eq_single_add_erase
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ update i f b = single i b + erase i f

tactic: rcases eq_or_ne i j with (rfl | h)
state_before: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
⊢ ↑(update i f b) j = ↑(single i b + erase i f) j

tactic: simp
state_before: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ ↑(update i f b) i = ↑(single i b + erase i f) i

tactic: simp [Function.update_noteq h.symm, h, erase_ne, h.symm]
state_before: case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
h : i ≠ j
⊢ ↑(update i f b) j = ↑(single i b + erase i f) j
Theorem: CategoryTheory.Limits.pullback_diagonal_map_snd_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: simp [condition]
state_before: C : Type ?u.280870
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f

tactic: simp [condition]
state_before: C : Type ?u.280870
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f

tactic: conv_rhs => rw [← Category.comp_id pullback.fst]
state_before: C : Type u_2
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd ≫ snd ≫ i₂ ≫ fst = fst

tactic: rw [← diagonal_snd f, pullback.condition_assoc, pullback.lift_snd]
state_before: C : Type u_2
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd ≫ snd ≫ i₂ ≫ fst = fst ≫ 𝟙 X
Theorem: FirstOrder.Language.Substructure.lift_card_closure_le
File: Mathlib/ModelTheory/Substructures.lean

tactic: rw [← lift_umax]
state_before: L : Language
M : Type w
N : Type ?u.34936
P : Type ?u.34939
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
s : Set M
⊢ lift (#{ x // x ∈ LowerAdjoint.toFun (closure L) s }) ≤ max ℵ₀ (lift (#↑s) + lift (#(i : ℕ) × Functions L i))

tactic: refine' lift_card_closure_le_card_term.trans (Term.card_le.trans _)
state_before: L : Language
M : Type w
N : Type ?u.34936
P : Type ?u.34939
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
s : Set M
⊢ lift (#{ x // x ∈ LowerAdjoint.toFun (closure L) s }) ≤ max ℵ₀ (lift (#↑s) + lift (#(i : ℕ) × Functions L i))

tactic: rw [mk_sum, lift_umax.{w, u}]
state_before: L : Language
M : Type w
N : Type ?u.34936
P : Type ?u.34939
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
s : Set M
⊢ max ℵ₀ (#↑s ⊕ (i : ℕ) × Functions L i) ≤ max ℵ₀ (lift (#↑s) + lift (#(i : ℕ) × Functions L i))
Theorem: PowerBasis.finrank
File: Mathlib/RingTheory/PowerBasis.lean

tactic: rw [FiniteDimensional.finrank_eq_card_basis pb.basis, Fintype.card_fin]
state_before: R : Type ?u.10641
S : Type u_2
T : Type ?u.10647
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
A : Type ?u.10950
B : Type ?u.10953
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : IsDomain B
inst✝² : Algebra A B
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra K S
pb : PowerBasis K S
⊢ FiniteDimensional.finrank K S = pb.dim
Theorem: Real.ciInf_const_zero
File: Mathlib/Data/Real/Basic.lean

tactic: cases isEmpty_or_nonempty α
state_before: x y : ℝ
α : Sort u_1
⊢ (⨅ (x : α), 0) = 0

tactic: exact Real.ciInf_empty _
state_before: case inl
x y : ℝ
α : Sort u_1
h✝ : IsEmpty α
⊢ (⨅ (x : α), 0) = 0

tactic: exact ciInf_const
state_before: case inr
x y : ℝ
α : Sort u_1
h✝ : Nonempty α
⊢ (⨅ (x : α), 0) = 0
Theorem: Finsupp.lmapDomain_total
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext l
state_before: α : Type u_4
M : Type u_2
N : Type ?u.336034
P : Type ?u.336037
R : Type u_1
S : Type ?u.336043
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type u_5
M' : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), ↑g (v i) = v' (f i)
⊢ comp (Finsupp.total α' M' R v') (lmapDomain R R f) = comp g (Finsupp.total α M R v)

tactic: simp [total_apply, Finsupp.sum_mapDomain_index, add_smul, h]
state_before: case h.h
α : Type u_4
M : Type u_2
N : Type ?u.336034
P : Type ?u.336037
R : Type u_1
S : Type ?u.336043
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type u_5
M' : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), ↑g (v i) = v' (f i)
l : α
⊢ ↑(comp (comp (Finsupp.total α' M' R v') (lmapDomain R R f)) (lsingle l)) 1 =
    ↑(comp (comp g (Finsupp.total α M R v)) (lsingle l)) 1
Theorem: multiplicity.eq_coe_iff
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← PartENat.some_eq_natCast]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
n : ℕ
⊢ multiplicity a b = ↑n ↔ a ^ n ∣ b ∧ ¬a ^ (n + 1) ∣ b

tactic: exact
  ⟨fun h =>
    let ⟨h₁, h₂⟩ := eq_some_iff.1 h
    h₂ ▸ ⟨pow_multiplicity_dvd _, is_greatest (by
            rw [PartENat.lt_coe_iff]
            exact ⟨h₁, lt_succ_self _⟩)⟩,
    fun h => eq_some_iff.2 ⟨⟨n, h.2⟩, Eq.symm <| unique' h.1 h.2⟩⟩
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
n : ℕ
⊢ multiplicity a b = ↑n ↔ a ^ n ∣ b ∧ ¬a ^ (n + 1) ∣ b

tactic: rw [PartENat.lt_coe_iff]
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
n : ℕ
h : multiplicity a b = ↑n
h₁ : (multiplicity a b).Dom
h₂ : Part.get (multiplicity a b) h₁ = n
⊢ multiplicity a b < ↑(Part.get (multiplicity a b) h₁ + 1)

tactic: exact ⟨h₁, lt_succ_self _⟩
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
n : ℕ
h : multiplicity a b = ↑n
h₁ : (multiplicity a b).Dom
h₂ : Part.get (multiplicity a b) h₁ = n
⊢ ∃ h, Part.get (multiplicity a b) h < Part.get (multiplicity a b) h₁ + 1
Theorem: ENNReal.tendsto_inv_iff
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa only [inv_inv] using Tendsto.inv h
state_before: α : Type u_1
β : Type ?u.123804
γ : Type ?u.123807
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a : ℝ≥0∞
h : Tendsto (fun x => (m x)⁻¹) f (𝓝 a⁻¹)
⊢ Tendsto m f (𝓝 a)
Theorem: Subtype.coind_injective
File: Mathlib/Data/Subtype.lean

tactic: apply congr_arg Subtype.val hxy
state_before: α✝ : Sort ?u.7280
β✝ : Sort ?u.7283
γ : Sort ?u.7286
p✝ q : α✝ → Prop
α : Sort u_1
β : Sort u_2
f : α → β
p : β → Prop
h : ∀ (a : α), p (f a)
hf : Injective f
x y : α
hxy : coind f h x = coind f h y
⊢ f x = f y
Theorem: Real.sin_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ sin (3 * x) = 3 * sin x - 4 * sin x ^ 3

tactic: simp [sin_three_mul]
state_before: x y : ℝ
⊢ ↑(sin (3 * x)) = ↑(3 * sin x - 4 * sin x ^ 3)
Theorem: EulerSine.antideriv_sin_comp_const_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

tactic: have a : HasDerivAt (fun y : ℂ => y * (2 * z)) _ x := hasDerivAt_mul_const _
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x

tactic: have b : HasDerivAt (fun y : ℂ => Complex.cos (y * (2 * z))) _ x :=
  HasDerivAt.comp (x : ℂ) (Complex.hasDerivAt_cos (x * (2 * z))) a
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x

tactic: have c := (b.comp_ofReal.div_const (2 * z)).neg
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.cos (y * (2 * z))) (-Complex.sin (↑x * (2 * z)) * (2 * z)) ↑x
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x

tactic: field_simp at c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.cos (y * (2 * z))) (-Complex.sin (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => -(Complex.cos (↑x * (2 * z)) / (2 * z))) (-(-Complex.sin (↑x * (2 * z)) * (2 * z) / (2 * z))) x
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x

tactic: simp only [fun y => mul_comm y (2 * z)] at c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.cos (y * (2 * z))) (-Complex.sin (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => -Complex.cos (↑x * (2 * z)) / (2 * z)) (Complex.sin (↑x * (2 * z))) x
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x

tactic: exact c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.cos (y * (2 * z))) (-Complex.sin (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => -Complex.cos (2 * z * ↑x) / (2 * z)) (Complex.sin (2 * z * ↑x)) x
⊢ HasDerivAt (fun y => -Complex.cos (2 * z * ↑y) / (2 * z)) (Complex.sin (2 * z * ↑x)) x
Theorem: ENorm.map_sub_rev
File: Mathlib/Analysis/NormedSpace/ENorm.lean

tactic: rw [← neg_sub, e.map_neg]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x y : V
⊢ ↑e (x - y) = ↑e (y - x)
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_inter'
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rw [LiftPropWithinAt, LiftPropWithinAt, continuousWithinAt_inter' ht, hG.congr_set]
state_before: H : Type u_2
M : Type u_1
H' : Type u_3
M' : Type u_4
X : Type ?u.33513
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
ht : t ∈ 𝓝[s] x
⊢ LiftPropWithinAt P g (s ∩ t) x ↔ LiftPropWithinAt P g s x

tactic: simp_rw [eventuallyEq_set, mem_preimage,
  (chartAt _ x).eventually_nhds' (fun x ↦ x ∈ s ∩ t ↔ x ∈ s) (mem_chart_source _ x)]
state_before: H : Type u_2
M : Type u_1
H' : Type u_3
M' : Type u_4
X : Type ?u.33513
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
ht : t ∈ 𝓝[s] x
⊢ ↑(LocalHomeomorph.symm (chartAt H x)) ⁻¹' (s ∩ t) =ᶠ[𝓝 (↑(chartAt H x) x)] ↑(LocalHomeomorph.symm (chartAt H x)) ⁻¹' s

tactic: exact (mem_nhdsWithin_iff_eventuallyEq.mp ht).symm.mem_iff
state_before: H : Type u_2
M : Type u_1
H' : Type u_3
M' : Type u_4
X : Type ?u.33513
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
ht : t ∈ 𝓝[s] x
⊢ ∀ᶠ (x : M) in 𝓝 x, x ∈ s ∩ t ↔ x ∈ s
Theorem: Bool.and_or_distrib_right
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> cases b <;> cases c <;> simp
state_before: a b c : Bool
⊢ ((a || b) && c) = (a && c || b && c)
Theorem: Fin.castAdd_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
⊢ ↑(castAdd 0) = ↑(cast (_ : n = n))

tactic: simp only [Nat.add_zero, cast_refl, OrderIso.refl_apply]
state_before: case h.h
n m : ℕ
x✝ : Fin n
⊢ ↑(↑(castAdd 0) x✝) = ↑(↑(cast (_ : n = n)) x✝)

tactic: rfl
state_before: case h.h
n m : ℕ
x✝ : Fin n
⊢ ↑(↑(castAdd 0) x✝) = ↑x✝
Theorem: CircleDeg1Lift.le_iterate_of_add_int_le_map
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
  (f.commute_add_int m).symm.iterate_le_of_map_le (monotone_id.add_const (m : ℝ)) f.monotone h n
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
h : x + ↑m ≤ ↑f x
n : ℕ
⊢ x + ↑n * ↑m ≤ (↑f^[n]) x
Theorem: Std.RBNode.find?_some_eq_eq
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [find?]
state_before: α : Type u_1
x : α
cut : α → Ordering
t : RBNode α
⊢ x ∈ find? cut t → cut x = Ordering.eq

tactic: split <;> try assumption
state_before: case node
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
⊢ (match cut v✝ with
      | Ordering.lt => find? cut l✝
      | Ordering.gt => find? cut r✝
      | Ordering.eq => some v✝) =
      some x →
    cut x = Ordering.eq

tactic: intro | rfl => assumption
state_before: case node.h_3
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ some v✝ = some x → cut x = Ordering.eq

tactic: assumption
state_before: case node.h_3
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ some v✝ = some x → cut x = Ordering.eq

tactic: assumption
state_before: α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝¹ : Ordering
heq✝ : cut v✝ = Ordering.eq
x✝ : some v✝ = some x
l_ih✝ : v✝ ∈ find? cut l✝ → cut v✝ = Ordering.eq
r_ih✝ : v✝ ∈ find? cut r✝ → cut v✝ = Ordering.eq
⊢ cut v✝ = Ordering.eq
Theorem: ContinuousOn.div_const
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul continuousOn_const
state_before: α : Type u_1
β : Type ?u.4103
G₀ : Type u_2
inst✝³ : DivInvMonoid G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : ContinuousMul G₀
f : α → G₀
s : Set α
l : Filter α
inst✝ : TopologicalSpace α
hf : ContinuousOn f s
y : G₀
⊢ ContinuousOn (fun x => f x / y) s
Theorem: MeasureTheory.L2.mem_L1_inner
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: simp_rw [mem_Lp_iff_snorm_lt_top, snorm_aeeqFun]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.97006
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
⊢ AEEqFun.mk (fun x => inner (↑↑f x) (↑↑g x)) (_ : AEStronglyMeasurable (fun x => inner (↑↑f x) (↑↑g x)) μ) ∈ Lp 𝕜 1

tactic: exact snorm_inner_lt_top f g
state_before: α : Type u_1
E : Type u_2
F : Type ?u.97006
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f g : { x // x ∈ Lp E 2 }
⊢ snorm (fun x => inner (↑↑f x) (↑↑g x)) 1 μ < ⊤
Theorem: Algebra.adjoin_image
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: simp only [Set.image_id', coe_carrier_toSubmonoid, Subalgebra.coe_toSubsemiring,
  Subalgebra.coe_comap]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s✝ t : Set A
f : A →ₐ[R] B
s : Set A
⊢ (fun x => x) '' s ⊆ (Subalgebra.comap f (adjoin R (↑f '' s))).toSubsemiring.toSubmonoid.toSubsemigroup.carrier

tactic: exact fun x hx => subset_adjoin ⟨x, hx, rfl⟩
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s✝ t : Set A
f : A →ₐ[R] B
s : Set A
⊢ s ⊆ ↑f ⁻¹' ↑(adjoin R ((fun a => ↑f a) '' s))
Theorem: MeasureTheory.lintegral_eq_zero_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: haveI := isOpenPosMeasure_of_mulLeftInvariant_of_regular hμ
state_before: 𝕜 : Type ?u.93658
M : Type ?u.93661
α : Type ?u.93664
G : Type u_1
E : Type ?u.93670
F : Type ?u.93673
inst✝¹⁰ : MeasurableSpace G
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g : G
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : TopologicalGroup G
inst✝² : BorelSpace G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
hμ : μ ≠ 0
f : G → ℝ≥0∞
hf : Continuous f
⊢ (∫⁻ (x : G), f x ∂μ) = 0 ↔ f = 0

tactic: rw [lintegral_eq_zero_iff hf.measurable, hf.ae_eq_iff_eq μ continuous_zero]
state_before: 𝕜 : Type ?u.93658
M : Type ?u.93661
α : Type ?u.93664
G : Type u_1
E : Type ?u.93670
F : Type ?u.93673
inst✝¹⁰ : MeasurableSpace G
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g : G
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : TopologicalGroup G
inst✝² : BorelSpace G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
hμ : μ ≠ 0
f : G → ℝ≥0∞
hf : Continuous f
this : IsOpenPosMeasure μ
⊢ (∫⁻ (x : G), f x ∂μ) = 0 ↔ f = 0
Theorem: PartENat.add_left_cancel_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [add_comm a, add_comm a, PartENat.add_right_cancel_iff ha]
state_before: a b c : PartENat
ha : a ≠ ⊤
⊢ a + b = a + c ↔ b = c
Theorem: Set.univ_pi_subset_univ_pi_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [pi_subset_pi_iff]
state_before: ι : Type u_2
α : ι → Type u_1
β : ι → Type ?u.156455
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ pi univ t₁ ⊆ pi univ t₂ ↔ (∀ (i : ι), t₁ i ⊆ t₂ i) ∨ ∃ i, t₁ i = ∅
Theorem: List.foldl_eq_foldr
File: Mathlib/Data/List/Basic.lean

tactic: simp only [foldr_cons, foldl_eq_of_comm_of_assoc hcomm hassoc]
state_before: ι : Type ?u.249628
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b : α
l : List α
⊢ foldl f a (b :: l) = foldr f a (b :: l)

tactic: rw [foldl_eq_foldr a l]
state_before: ι : Type ?u.249628
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b : α
l : List α
⊢ f b (foldl f a l) = f b (foldr f a l)
Theorem: MonoidHom.range_eq_map
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: ext
state_before: G : Type u_1
G' : Type ?u.457281
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.457290
inst✝² : AddGroup A
N : Type u_2
P : Type ?u.457299
inst✝¹ : Group N
inst✝ : Group P
K : Subgroup G
f : G →* N
⊢ range f = map f ⊤

tactic: simp
state_before: case h
G : Type u_1
G' : Type ?u.457281
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.457290
inst✝² : AddGroup A
N : Type u_2
P : Type ?u.457299
inst✝¹ : Group N
inst✝ : Group P
K : Subgroup G
f : G →* N
x✝ : N
⊢ x✝ ∈ range f ↔ x✝ ∈ map f ⊤