tasksource/leandojo huggingface dataset:
Theorem: Pretrivialization.linearMapAt_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [coe_linearMapAt]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y✝ : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
y : E b
⊢ ↑(Pretrivialization.linearMapAt R e b) y = if b ∈ e.baseSet then (↑e (totalSpaceMk b y)).snd else 0
Theorem: CategoryTheory.Subobject.inf_factors
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: revert X Y
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A B : C
X Y : Subobject B
f : A ⟶ B
⊢ Factors X f ∧ Factors Y f → Factors (X ⊓ Y) f

tactic: apply Quotient.ind₂'
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ {X Y : Subobject B}, Factors X f ∧ Factors Y f → Factors (X ⊓ Y) f

tactic: rintro X Y ⟨⟨g₁, rfl⟩, ⟨g₂, hg₂⟩⟩
state_before: case h
C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A B : C
f : A ⟶ B
⊢ ∀ (a₁ a₂ : MonoOver B),
    Factors (Quotient.mk'' a₁) f ∧ Factors (Quotient.mk'' a₂) f → Factors (Quotient.mk'' a₁ ⊓ Quotient.mk'' a₂) f

tactic: exact ⟨_, pullback.lift_snd_assoc _ _ hg₂ _⟩
state_before: case h.intro.intro.intro
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A B : C
X Y : MonoOver B
g₁ : A ⟶ X.obj.left
g₂ : A ⟶ Y.obj.left
hg₂ : g₂ ≫ MonoOver.arrow Y = g₁ ≫ MonoOver.arrow X
⊢ Factors (Quotient.mk'' X ⊓ Quotient.mk'' Y) (g₁ ≫ MonoOver.arrow X)
Theorem: Ordinal.dvd_add_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [mul_sub, ← e, add_sub_cancel]
state_before: α : Type ?u.249217
β : Type ?u.249220
γ : Type ?u.249223
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c b : Ordinal
x✝ : a ∣ a * b + c
d : Ordinal
e : a * b + c = a * d
⊢ c = a * (d - b)

tactic: rw [e, ← mul_add]
state_before: α : Type ?u.249217
β : Type ?u.249220
γ : Type ?u.249223
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c b : Ordinal
x✝ : a ∣ c
d : Ordinal
e : c = a * d
⊢ a ∣ a * b + c

tactic: apply dvd_mul_right
state_before: α : Type ?u.249217
β : Type ?u.249220
γ : Type ?u.249223
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c b : Ordinal
x✝ : a ∣ c
d : Ordinal
e : c = a * d
⊢ a ∣ a * (b + d)
Theorem: Primrec₂.of_eq
File: Mathlib/Computability/Primrec.lean

tactic: funext a b
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
⊢ f = g

tactic: apply H
state_before: case h.h
α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f g : α → β → σ
hg : Primrec₂ f
H : ∀ (a : α) (b : β), f a b = g a b
a : α
b : β
⊢ f a b = g a b
Theorem: uniq_inv_of_isField
File: Mathlib/Algebra/Field/Defs.lean

tactic: intro x hx
state_before: α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
⊢ ∀ (x : R), x ≠ 0 → ∃! y, x * y = 1

tactic: apply exists_unique_of_exists_of_unique
state_before: α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃! y, x * y = 1

tactic: exact hf.mul_inv_cancel hx
state_before: case hex
α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃ x_1, x * x_1 = 1

tactic: intro y z hxy hxz
state_before: case hunique
α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∀ (y₁ y₂ : R), x * y₁ = 1 → x * y₂ = 1 → y₁ = y₂

tactic: calc
  y = y * (x * z) := by rw [hxz, mul_one]
  _ = x * y * z := by rw [← mul_assoc, hf.mul_comm y x]
  _ = z := by rw [hxy, one_mul]
state_before: case hunique
α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
y z : R
hxy : x * y = 1
hxz : x * z = 1
⊢ y = z

tactic: rw [hxz, mul_one]
state_before: α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
y z : R
hxy : x * y = 1
hxz : x * z = 1
⊢ y = y * (x * z)

tactic: rw [← mul_assoc, hf.mul_comm y x]
state_before: α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
y z : R
hxy : x * y = 1
hxz : x * z = 1
⊢ y * (x * z) = x * y * z

tactic: rw [hxy, one_mul]
state_before: α : Type ?u.15083
β : Type ?u.15086
K : Type ?u.15089
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
y z : R
hxy : x * y = 1
hxz : x * z = 1
⊢ x * y * z = z
Theorem: Filter.iSup_ultrafilter_le_eq
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: simp only [iSup_le_iff, ← le_iff_ultrafilter]
state_before: α : Type u
β : Type v
γ : Type ?u.42657
f✝ : Filter α
s : Set α
a : α
f f' : Filter α
⊢ (⨆ (g : Ultrafilter α) (_ : ↑g ≤ f), ↑g) ≤ f' ↔ f ≤ f'
Theorem: Cardinal.toNat_lift
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: apply natCast_injective
state_before: α β : Type u
c : Cardinal
⊢ ↑toNat (lift c) = ↑toNat c

tactic: cases' lt_or_ge c ℵ₀ with hc hc
state_before: case a
α β : Type u
c : Cardinal
⊢ ↑(↑toNat (lift c)) = ↑(↑toNat c)

tactic: rw [cast_toNat_of_lt_aleph0, ← lift_natCast.{u,v}, cast_toNat_of_lt_aleph0 hc]
state_before: case a.inl
α β : Type u
c : Cardinal
hc : c < ℵ₀
⊢ ↑(↑toNat (lift c)) = ↑(↑toNat c)

tactic: rwa [lift_lt_aleph0]
state_before: case a.inl
α β : Type u
c : Cardinal
hc : c < ℵ₀
⊢ lift c < ℵ₀

tactic: rw [cast_toNat_of_aleph0_le, ← lift_natCast.{u,v}, cast_toNat_of_aleph0_le hc, lift_zero]
state_before: case a.inr
α β : Type u
c : Cardinal
hc : c ≥ ℵ₀
⊢ ↑(↑toNat (lift c)) = ↑(↑toNat c)

tactic: rwa [aleph0_le_lift]
state_before: case a.inr
α β : Type u
c : Cardinal
hc : c ≥ ℵ₀
⊢ ℵ₀ ≤ lift c
Theorem: Pi.mulSingle_comm
File: Mathlib/Data/Pi/Algebra.lean

tactic: simp [mulSingle_apply, eq_comm]
state_before: I : Type u
α : Type ?u.12756
β : Type u_1
γ : Type ?u.12762
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
inst✝⁴ : DecidableEq I
inst✝³ : (i : I) → One (f i)
inst✝² : (i : I) → One (g i)
inst✝¹ : (i : I) → One (h i)
inst✝ : One β
i : I
x : β
i' : I
⊢ mulSingle i x i' = mulSingle i' x i
Theorem: Dfinsupp.coe_piecewise
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
x y : Π₀ (i : ι), β i
s : Set ι
inst✝ : (i : ι) → Decidable (i ∈ s)
⊢ ↑(piecewise x y s) = Set.piecewise s ↑x ↑y

tactic: apply piecewise_apply
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → Zero (β₁ i)
inst✝¹ : (i : ι) → Zero (β₂ i)
x y : Π₀ (i : ι), β i
s : Set ι
inst✝ : (i : ι) → Decidable (i ∈ s)
x✝ : ι
⊢ ↑(piecewise x y s) x✝ = Set.piecewise s (↑x) (↑y) x✝
Theorem: Fin.addNat_one
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
i : Fin n
⊢ ↑(addNat 1) i = succ i

tactic: rw [coe_addNat, val_succ]
state_before: case h
n m : ℕ
i : Fin n
⊢ ↑(↑(addNat 1) i) = ↑(succ i)
Theorem: LocalHomeomorph.isOpen_extend_preimage
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [← extend_source f I]
state_before: 𝕜 : Type u_4
E : Type u_1
M : Type u_2
H : Type u_3
E' : Type ?u.149123
M' : Type ?u.149126
H' : Type ?u.149129
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s✝ t : Set M
s : Set E
hs : IsOpen s
⊢ IsOpen (f.source ∩ ↑(extend f I) ⁻¹' s)

tactic: exact isOpen_extend_preimage' f I hs
state_before: 𝕜 : Type u_4
E : Type u_1
M : Type u_2
H : Type u_3
E' : Type ?u.149123
M' : Type ?u.149126
H' : Type ?u.149129
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s✝ t : Set M
s : Set E
hs : IsOpen s
⊢ IsOpen ((extend f I).source ∩ ↑(extend f I) ⁻¹' s)
Theorem: abs_le_max_abs_abs
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: simp [hbc.trans (le_abs_self c)]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hab : a ≤ b
hbc : b ≤ c
⊢ b ≤ max (abs a) (abs c)

tactic: simp [((@neg_le_neg_iff α ..).mpr hab).trans (neg_le_abs_self a)]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
hab : a ≤ b
hbc : b ≤ c
⊢ -b ≤ max (abs a) (abs c)
Theorem: FractionalIdeal.spanSingleton_pow
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: induction' n with n hn
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
R₁ : Type ?u.1336678
inst✝³ : CommRing R₁
K : Type ?u.1336684
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x : P
n : ℕ
⊢ spanSingleton S x ^ n = spanSingleton S (x ^ n)

tactic: rw [pow_zero, pow_zero, spanSingleton_one]
state_before: case zero
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
R₁ : Type ?u.1336678
inst✝³ : CommRing R₁
K : Type ?u.1336684
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x : P
⊢ spanSingleton S x ^ Nat.zero = spanSingleton S (x ^ Nat.zero)

tactic: rw [pow_succ, hn, spanSingleton_mul_spanSingleton, pow_succ]
state_before: case succ
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
R₁ : Type ?u.1336678
inst✝³ : CommRing R₁
K : Type ?u.1336684
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x : P
n : ℕ
hn : spanSingleton S x ^ n = spanSingleton S (x ^ n)
⊢ spanSingleton S x ^ Nat.succ n = spanSingleton S (x ^ Nat.succ n)
Theorem: Ordinal.enum_succ_eq_top
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [type_lt]
state_before: α : Type ?u.99408
β : Type ?u.99411
γ : Type ?u.99414
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ o < type fun x x_1 => x < x_1

tactic: exact lt_succ o
state_before: α : Type ?u.99408
β : Type ?u.99411
γ : Type ?u.99414
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ o < succ o
Theorem: LieSubmodule.comap_bracket_eq
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: conv_lhs => rw [← map_comap_eq N₂ f hf₂]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
hf₁ : LieModuleHom.ker f = ⊥
hf₂ : N₂ ≤ LieModuleHom.range f
⊢ comap f ⁅I, N₂⁆ = ⁅I, comap f N₂⁆

tactic: rw [← map_bracket_eq, comap_map_eq _ f hf₁]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
hf₁ : LieModuleHom.ker f = ⊥
hf₂ : N₂ ≤ LieModuleHom.range f
⊢ comap f ⁅I, map f (comap f N₂)⁆ = ⁅I, comap f N₂⁆
Theorem: summable_norm_pow_mul_geometric_of_norm_lt_1
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rcases exists_between hr with ⟨r', hrr', h⟩
state_before: α : Type ?u.150661
β : Type ?u.150664
ι : Type ?u.150667
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r : R
hr : ‖r‖ < 1
⊢ Summable fun n => ‖↑n ^ k * r ^ n‖

tactic: exact summable_of_isBigO_nat (summable_geometric_of_lt_1 ((norm_nonneg _).trans hrr'.le) h)
  (isLittleO_pow_const_mul_const_pow_const_pow_of_norm_lt _ hrr').isBigO.norm_left
state_before: case intro.intro
α : Type ?u.150661
β : Type ?u.150664
ι : Type ?u.150667
R : Type u_1
inst✝ : NormedRing R
k : ℕ
r : R
hr : ‖r‖ < 1
r' : ℝ
hrr' : ‖r‖ < r'
h : r' < 1
⊢ Summable fun n => ‖↑n ^ k * r ^ n‖
Theorem: Summable.tendsto_cofinite_zero
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: intro e he
state_before: α : Type u_2
β : Type ?u.775371
γ : Type ?u.775374
δ : Type ?u.775377
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
⊢ Tendsto f cofinite (𝓝 0)

tactic: rw [Filter.mem_map]
state_before: α : Type u_2
β : Type ?u.775371
γ : Type ?u.775374
δ : Type ?u.775377
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
⊢ e ∈ Filter.map f cofinite

tactic: rcases hf.vanishing he with ⟨s, hs⟩
state_before: α : Type u_2
β : Type ?u.775371
γ : Type ?u.775374
δ : Type ?u.775377
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
⊢ f ⁻¹' e ∈ cofinite

tactic: refine' s.eventually_cofinite_nmem.mono fun x hx => _
state_before: case intro
α : Type u_2
β : Type ?u.775371
γ : Type ?u.775374
δ : Type ?u.775377
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
s : Finset α
hs : ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e
⊢ f ⁻¹' e ∈ cofinite

tactic: simpa using hs {x} (disjoint_singleton_left.2 hx)
state_before: case intro
α : Type u_2
β : Type ?u.775371
γ : Type ?u.775374
δ : Type ?u.775377
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : AddCommGroup G
inst✝ : TopologicalAddGroup G
f : α → G
hf : Summable f
e : Set G
he : e ∈ 𝓝 0
s : Finset α
hs : ∀ (t : Finset α), Disjoint t s → ∑ k in t, f k ∈ e
x : α
hx : ¬x ∈ s
⊢ f x ∈ e
Theorem: List.zipLeft'_nil_right
File: Mathlib/Data/List/Basic.lean

tactic: cases as <;> rfl
state_before: ι : Type ?u.463625
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ zipLeft' as [] = (map (fun a => (a, none)) as, [])
Theorem: Fin.cons_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [cons]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y : α (succ i)
z : α 0
⊢ cons x p 0 = x
Theorem: Qpf.Cofix.bisim'
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: rcases h x' Qx' with ⟨a, f, f', ux'eq, vx'eq, h'⟩
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u_1
Q : α → Prop
u v : α → Cofix F
h :
  ∀ (x : α),
    Q x →
      ∃ a f f',
        dest (u x) = abs { fst := a, snd := f } ∧
          dest (v x) = abs { fst := a, snd := f' } ∧ ∀ (i : PFunctor.B (P F) a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
x✝¹ : α
Qx : Q x✝¹
R : Cofix F → Cofix F → Prop := fun w z => ∃ x', Q x' ∧ w = u x' ∧ z = v x'
x y : Cofix F
x✝ : R x y
x' : α
Qx' : Q x'
xeq : x = u x'
yeq : y = v x'
⊢ Liftr R (dest x) (dest y)

tactic: rw [liftr_iff]
state_before: case intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u_1
Q : α → Prop
u v : α → Cofix F
h :
  ∀ (x : α),
    Q x →
      ∃ a f f',
        dest (u x) = abs { fst := a, snd := f } ∧
          dest (v x) = abs { fst := a, snd := f' } ∧ ∀ (i : PFunctor.B (P F) a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
x✝¹ : α
Qx : Q x✝¹
R : Cofix F → Cofix F → Prop := fun w z => ∃ x', Q x' ∧ w = u x' ∧ z = v x'
x y : Cofix F
x✝ : R x y
x' : α
Qx' : Q x'
xeq : x = u x'
yeq : y = v x'
a : (P F).A
f f' : PFunctor.B (P F) a → Cofix F
ux'eq : dest (u x') = abs { fst := a, snd := f }
vx'eq : dest (v x') = abs { fst := a, snd := f' }
h' : ∀ (i : PFunctor.B (P F) a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
⊢ Liftr R (dest x) (dest y)

tactic: refine' ⟨a, f, f', xeq.symm ▸ ux'eq, yeq.symm ▸ vx'eq, h'⟩
state_before: case intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u_1
Q : α → Prop
u v : α → Cofix F
h :
  ∀ (x : α),
    Q x →
      ∃ a f f',
        dest (u x) = abs { fst := a, snd := f } ∧
          dest (v x) = abs { fst := a, snd := f' } ∧ ∀ (i : PFunctor.B (P F) a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
x✝¹ : α
Qx : Q x✝¹
R : Cofix F → Cofix F → Prop := fun w z => ∃ x', Q x' ∧ w = u x' ∧ z = v x'
x y : Cofix F
x✝ : R x y
x' : α
Qx' : Q x'
xeq : x = u x'
yeq : y = v x'
a : (P F).A
f f' : PFunctor.B (P F) a → Cofix F
ux'eq : dest (u x') = abs { fst := a, snd := f }
vx'eq : dest (v x') = abs { fst := a, snd := f' }
h' : ∀ (i : PFunctor.B (P F) a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x'
⊢ ∃ a f₀ f₁,
    dest x = abs { fst := a, snd := f₀ } ∧
      dest y = abs { fst := a, snd := f₁ } ∧ ∀ (i : PFunctor.B (P F) a), R (f₀ i) (f₁ i)
Theorem: LieIdeal.map_le_iff_le_comap
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [map_le]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
⊢ map f I ≤ J ↔ I ≤ comap f J

tactic: exact Set.image_subset_iff
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I I₂ : LieIdeal R L
J : LieIdeal R L'
⊢ ↑f '' ↑I ⊆ ↑J ↔ I ≤ comap f J
Theorem: Mathlib.Tactic.Ring.neg_zero
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R✝ : Type ?u.213173
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
⊢ -0 = 0
Theorem: Nat.ArithmeticFunction.pow_zero_eq_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type ?u.511482
⊢ pow 0 = ζ

tactic: simp
state_before: case h
R : Type ?u.511482
n : ℕ
⊢ ↑(pow 0) n = ↑ζ n
Theorem: Polynomial.card_rootSet_eq_natDegree
File: Mathlib/FieldTheory/Separable.lean

tactic: simp_rw [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : Separable p
hsplit : Splits (algebraMap F K) p
⊢ Fintype.card ↑(rootSet p K) = natDegree p

tactic: rw [Multiset.toFinset_card_of_nodup, ← natDegree_eq_card_roots hsplit]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : Separable p
hsplit : Splits (algebraMap F K) p
⊢ card (Multiset.toFinset (roots (map (algebraMap F K) p))) = natDegree p

tactic: exact nodup_roots hsep.map
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : Separable p
hsplit : Splits (algebraMap F K) p
⊢ Multiset.Nodup (roots (map (algebraMap F K) p))
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.add
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [add_eq_map₂]
state_before: α : Type u_2
β✝ : Type ?u.913715
γ : Type ?u.913718
δ : Type ?u.913721
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_1
inst✝ : AddMonoid β
f g : α →ₛ β
hf : SimpleFunc.FinMeasSupp f μ
hg : SimpleFunc.FinMeasSupp g μ
⊢ SimpleFunc.FinMeasSupp (f + g) μ

tactic: exact hf.map₂ hg (zero_add 0)
state_before: α : Type u_2
β✝ : Type ?u.913715
γ : Type ?u.913718
δ : Type ?u.913721
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_1
inst✝ : AddMonoid β
f g : α →ₛ β
hf : SimpleFunc.FinMeasSupp f μ
hg : SimpleFunc.FinMeasSupp g μ
⊢ SimpleFunc.FinMeasSupp (map (fun p => p.fst + p.snd) (pair f g)) μ
Theorem: Asymptotics.isLittleO_pow_sub_sub
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [isLittleO_norm_right, pow_one] using isLittleO_pow_sub_pow_sub x₀ h
state_before: α : Type ?u.660809
β : Type ?u.660812
E : Type ?u.660815
F : Type ?u.660818
G : Type ?u.660821
E' : Type u_1
F' : Type ?u.660827
G' : Type ?u.660830
E'' : Type ?u.660833
F'' : Type ?u.660836
G'' : Type ?u.660839
R : Type ?u.660842
R' : Type ?u.660845
𝕜 : Type ?u.660848
𝕜' : Type ?u.660851
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
x₀ : E'
m : ℕ
h : 1 < m
⊢ (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => x - x₀
Theorem: Int.neg_modEq_neg
File: Mathlib/Data/Int/ModEq.lean

tactic: simp [-sub_neg_eq_add, neg_sub_neg, modEq_iff_dvd, dvd_sub_comm]
state_before: m n a b c d : ℤ
⊢ -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n]
Theorem: ConvexOn.map_integral_le
File: Mathlib/Analysis/Convex/Integral.lean

tactic: simpa only [average_eq_integral] using
  hg.map_average_le hgc hsc (IsProbabilityMeasure.ne_zero μ) hfs hfi hgi
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1581214
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : IsProbabilityMeasure μ
hg : ConvexOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f
hgi : Integrable (g ∘ f)
⊢ g (∫ (x : α), f x ∂μ) ≤ ∫ (x : α), g (f x) ∂μ
Theorem: LinearMap.inl_injective
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.51858
M₆ : Type ?u.51861
S : Type ?u.51864
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
x✝ : M
⊢ ∀ ⦃a₂ : M⦄, ↑(inl R M M₂) x✝ = ↑(inl R M M₂) a₂ → x✝ = a₂
Theorem: MvPolynomial.monomial_one_dvd_monomial_one
File: Mathlib/Data/MvPolynomial/Division.lean

tactic: rw [monomial_dvd_monomial]
state_before: σ : Type u_2
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
i j : σ →₀ ℕ
⊢ ↑(monomial i) 1 ∣ ↑(monomial j) 1 ↔ i ≤ j

tactic: simp_rw [one_ne_zero, false_or_iff, dvd_rfl, and_true_iff]
state_before: σ : Type u_2
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
i j : σ →₀ ℕ
⊢ (1 = 0 ∨ i ≤ j) ∧ 1 ∣ 1 ↔ i ≤ j