tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.CompatiblePreserving.apply_map
File: Mathlib/CategoryTheory/Sites/CoverPreserving.lean

tactic: unfold FamilyOfElements.functorPushforward
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A : Type u₃
inst✝ : Category A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
G : C ⥤ D
hG : CompatiblePreserving K G
ℱ : SheafOfTypes K
Z : C
T : Presieve Z
x : FamilyOfElements (Functor.op G ⋙ ℱ.val) T
h : FamilyOfElements.Compatible x
Y : C
f : Y ⟶ Z
hf : T f
⊢ FamilyOfElements.functorPushforward G x (G.map f) (_ : Presieve.functorPushforward G T (G.map f)) = x f hf

tactic: rcases e₁ : getFunctorPushforwardStructure (image_mem_functorPushforward G T hf) with
  ⟨X, g, f', hg, eq⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A : Type u₃
inst✝ : Category A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
G : C ⥤ D
hG : CompatiblePreserving K G
ℱ : SheafOfTypes K
Z : C
T : Presieve Z
x : FamilyOfElements (Functor.op G ⋙ ℱ.val) T
h : FamilyOfElements.Compatible x
Y : C
f : Y ⟶ Z
hf : T f
⊢ (FunctorPushforwardStructure.casesOn (getFunctorPushforwardStructure (_ : Presieve.functorPushforward G T (G.map f)))
      fun Z_1 g h h₁ fac => ℱ.val.map h.op (x g h₁)) =
    x f hf

tactic: simpa using hG.Compatible ℱ h f' (𝟙 _) hg hf (by simp [eq])
state_before: case mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A : Type u₃
inst✝ : Category A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
G : C ⥤ D
hG : CompatiblePreserving K G
ℱ : SheafOfTypes K
Z : C
T : Presieve Z
x : FamilyOfElements (Functor.op G ⋙ ℱ.val) T
h : FamilyOfElements.Compatible x
Y : C
f : Y ⟶ Z
hf : T f
X : C
g : X ⟶ Z
f' : G.obj Y ⟶ G.obj X
hg : T g
eq : G.map f = f' ≫ G.map g
e₁ :
  getFunctorPushforwardStructure (_ : Presieve.functorPushforward G T (G.map f)) =
    { preobj := X, premap := g, lift := f', cover := hg, fac := eq }
⊢ (FunctorPushforwardStructure.casesOn { preobj := X, premap := g, lift := f', cover := hg, fac := eq }
      fun Z_1 g h h₁ fac => ℱ.val.map h.op (x g h₁)) =
    x f hf

tactic: simp [eq]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A : Type u₃
inst✝ : Category A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
G : C ⥤ D
hG : CompatiblePreserving K G
ℱ : SheafOfTypes K
Z : C
T : Presieve Z
x : FamilyOfElements (Functor.op G ⋙ ℱ.val) T
h : FamilyOfElements.Compatible x
Y : C
f : Y ⟶ Z
hf : T f
X : C
g : X ⟶ Z
f' : G.obj Y ⟶ G.obj X
hg : T g
eq : G.map f = f' ≫ G.map g
e₁ :
  getFunctorPushforwardStructure (_ : Presieve.functorPushforward G T (G.map f)) =
    { preobj := X, premap := g, lift := f', cover := hg, fac := eq }
⊢ f' ≫ G.map g = 𝟙 (G.obj Y) ≫ G.map f
Theorem: Submodule.fg_ker_comp
File: Mathlib/RingTheory/Finiteness.lean

tactic: rw [LinearMap.ker_comp]
state_before: R✝ : Type ?u.275341
M✝ : Type ?u.275344
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P✝ : Type ?u.275380
inst✝⁸ : AddCommMonoid P✝
inst✝⁷ : Module R✝ P✝
f✝ : M✝ →ₗ[R✝] P✝
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf1 : FG (LinearMap.ker f)
hf2 : FG (LinearMap.ker g)
hsur : Surjective ↑f
⊢ FG (LinearMap.ker (LinearMap.comp g f))

tactic: apply fg_of_fg_map_of_fg_inf_ker f
state_before: R✝ : Type ?u.275341
M✝ : Type ?u.275344
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P✝ : Type ?u.275380
inst✝⁸ : AddCommMonoid P✝
inst✝⁷ : Module R✝ P✝
f✝ : M✝ →ₗ[R✝] P✝
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf1 : FG (LinearMap.ker f)
hf2 : FG (LinearMap.ker g)
hsur : Surjective ↑f
⊢ FG (comap f (LinearMap.ker g))

tactic: rwa [Submodule.map_comap_eq, LinearMap.range_eq_top.2 hsur, top_inf_eq]
state_before: case hs1
R✝ : Type ?u.275341
M✝ : Type ?u.275344
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P✝ : Type ?u.275380
inst✝⁸ : AddCommMonoid P✝
inst✝⁷ : Module R✝ P✝
f✝ : M✝ →ₗ[R✝] P✝
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf1 : FG (LinearMap.ker f)
hf2 : FG (LinearMap.ker g)
hsur : Surjective ↑f
⊢ FG (map f (comap f (LinearMap.ker g)))

tactic: rwa [inf_of_le_right (show (LinearMap.ker f) ≤
  (LinearMap.ker g).comap f from comap_mono bot_le)]
state_before: case hs2
R✝ : Type ?u.275341
M✝ : Type ?u.275344
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P✝ : Type ?u.275380
inst✝⁸ : AddCommMonoid P✝
inst✝⁷ : Module R✝ P✝
f✝ : M✝ →ₗ[R✝] P✝
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup P
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf1 : FG (LinearMap.ker f)
hf2 : FG (LinearMap.ker g)
hsur : Surjective ↑f
⊢ FG (comap f (LinearMap.ker g) ⊓ LinearMap.ker f)
Theorem: essSup_const
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: rw [← ae_neBot] at hμ
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLattice β
c : β
hμ : μ ≠ 0
⊢ essSup (fun x => c) μ = c

tactic: exact essSup_const' _
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝ : ConditionallyCompleteLattice β
c : β
hμ : NeBot (Measure.ae μ)
⊢ essSup (fun x => c) μ = c
Theorem: AddSubmonoid.mul_induction_on
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: simpa only [zero_mul] using hm _ (zero_mem _) _ (zero_mem _)
state_before: α : Type ?u.242292
G : Type ?u.242295
M✝ : Type ?u.242298
R : Type u_1
A : Type ?u.242304
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
M N : AddSubmonoid R
C : R → Prop
r : R
hr : r ∈ M * N
hm : ∀ (m : R), m ∈ M → ∀ (n : R), n ∈ N → C (m * n)
ha : ∀ (x y : R), C x → C y → C (x + y)
⊢ 0 ∈ { carrier := setOf C, add_mem' := (_ : ∀ {a b : R}, C a → C b → C (a + b)) }.carrier
Theorem: Finset.not_mem_uIcc_of_lt
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [mem_uIcc]
state_before: ι : Type ?u.204644
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬c ∈ [[a, b]]

tactic: exact Set.not_mem_uIcc_of_lt
state_before: ι : Type ?u.204644
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)
Theorem: Matrix.toEuclideanLin_conjTranspose_eq_adjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [LinearMap.eq_adjoint_iff]
state_before: 𝕜 : Type u_3
E : Type ?u.2437829
F : Type ?u.2437832
G : Type ?u.2437835
inst✝¹⁰ : IsROrC 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : InnerProductSpace 𝕜 G
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m n 𝕜
⊢ ↑toEuclideanLin Aᴴ = ↑LinearMap.adjoint (↑toEuclideanLin A)

tactic: intro x y
state_before: 𝕜 : Type u_3
E : Type ?u.2437829
F : Type ?u.2437832
G : Type ?u.2437835
inst✝¹⁰ : IsROrC 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : InnerProductSpace 𝕜 G
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m n 𝕜
⊢ ∀ (x : EuclideanSpace 𝕜 m) (y : (fun x => EuclideanSpace 𝕜 n) x),
    inner (↑(↑toEuclideanLin Aᴴ) x) y = inner x (↑(↑toEuclideanLin A) y)

tactic: simp_rw [EuclideanSpace.inner_eq_star_dotProduct, piLp_equiv_toEuclideanLin, toLin'_apply,
  star_mulVec, conjTranspose_conjTranspose, dotProduct_mulVec]
state_before: 𝕜 : Type u_3
E : Type ?u.2437829
F : Type ?u.2437832
G : Type ?u.2437835
inst✝¹⁰ : IsROrC 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : InnerProductSpace 𝕜 F
inst✝⁴ : InnerProductSpace 𝕜 G
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : DecidableEq m
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m n 𝕜
x : EuclideanSpace 𝕜 m
y : EuclideanSpace 𝕜 n
⊢ inner (↑(↑toEuclideanLin Aᴴ) x) y = inner x (↑(↑toEuclideanLin A) y)
Theorem: Finset.prod_sum_elim
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.309859
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
s : Finset α
t : Finset γ
f : α → β
g : γ → β
⊢ ∏ x in disjSum s t, Sum.elim f g x = (∏ x in s, f x) * ∏ x in t, g x
Theorem: LinearMap.quotientInfEquivSupQuotient_injective
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: rw [← ker_eq_bot, quotientInfToSupQuotient, ker_liftQ_eq_bot]
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.57346
M₃ : Type ?u.57349
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
⊢ Function.Injective ↑(quotientInfToSupQuotient p p')

tactic: rw [ker_comp, ker_mkQ]
state_before: case h'
R : Type u_1
M : Type u_2
M₂ : Type ?u.57346
M₃ : Type ?u.57349
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
⊢ ker (subToSupQuotient p p') ≤ comap (Submodule.subtype p) (p ⊓ p')

tactic: exact fun ⟨x, hx1⟩ hx2 => ⟨hx1, hx2⟩
state_before: case h'
R : Type u_1
M : Type u_2
M₂ : Type ?u.57346
M₃ : Type ?u.57349
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
⊢ comap (ofLe (_ : p ≤ p ⊔ p')) (comap (Submodule.subtype (p ⊔ p')) p') ≤ comap (Submodule.subtype p) (p ⊓ p')
Theorem: Set.isAtom_iff
File: Mathlib/Order/Atoms.lean

tactic: refine'
  ⟨_, by
    rintro ⟨x, rfl⟩
    exact isAtom_singleton x⟩
state_before: α : Type u_1
β : Type ?u.81171
s : Set α
⊢ IsAtom s ↔ ∃ x, s = {x}

tactic: rw [_root_.isAtom_iff, bot_eq_empty, ← nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type ?u.81171
s : Set α
⊢ IsAtom s → ∃ x, s = {x}

tactic: rintro ⟨⟨x, hx⟩, hs⟩
state_before: α : Type u_1
β : Type ?u.81171
s : Set α
⊢ (Set.Nonempty s ∧ ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b) → ∃ x, s = {x}

tactic: exact
  ⟨x, eq_singleton_iff_unique_mem.2
      ⟨hx, fun y hy => (hs {y} (singleton_ne_empty _) (singleton_subset_iff.2 hy) hx).symm⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.81171
s : Set α
hs : ∀ (b : Set α), b ≠ ∅ → b ≤ s → s ≤ b
x : α
hx : x ∈ s
⊢ ∃ x, s = {x}

tactic: rintro ⟨x, rfl⟩
state_before: α : Type u_1
β : Type ?u.81171
s : Set α
⊢ (∃ x, s = {x}) → IsAtom s

tactic: exact isAtom_singleton x
state_before: case intro
α : Type u_1
β : Type ?u.81171
x : α
⊢ IsAtom {x}
Theorem: PiLp.norm_eq_ciSup
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: dsimp [Norm.norm]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.25733
𝕜' : Type ?u.25736
ι : Type u_1
α : ι → Type ?u.25744
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → Norm (β i)
inst✝ : (i : ι) → Zero (β i)
f : PiLp ⊤ β
⊢ ‖f‖ = ⨆ (i : ι), ‖f i‖

tactic: exact if_neg ENNReal.top_ne_zero
state_before: p : ℝ≥0∞
𝕜 : Type ?u.25733
𝕜' : Type ?u.25736
ι : Type u_1
α : ι → Type ?u.25744
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → Norm (β i)
inst✝ : (i : ι) → Zero (β i)
f : PiLp ⊤ β
⊢ (if ⊤ = 0 then ↑(Finset.card (Finite.toFinset (_ : Set.Finite {i | f i ≠ 0})))
    else if ⊤ = ⊤ then ⨆ (i : ι), ‖f i‖ else (∑ i : ι, ‖f i‖ ^ 0) ^ (1 / 0)) =
    ⨆ (i : ι), ‖f i‖
Theorem: Submonoid.LocalizationMap.mk'_sec
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← sec_spec, mul_inv_left, mul_comm]
state_before: M : Type u_2
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type ?u.739560
inst✝ : CommMonoid P
f : LocalizationMap S N
z : N
⊢ ↑(toMap f) (sec f z).fst *
      ↑(↑(IsUnit.liftRight (MonoidHom.restrict (toMap f) S) (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(toMap f) ↑y)))
            (sec f z).snd)⁻¹ =
    z
Theorem: Set.add_mem_center
File: Mathlib/GroupTheory/Subsemigroup/Center.lean

tactic: rw [add_mul, mul_add, ha c, hb c]
state_before: M : Type u_1
inst✝ : Distrib M
a b : M
ha : a ∈ center M
hb : b ∈ center M
c : M
⊢ c * (a + b) = (a + b) * c
Theorem: tendsto_zero_iff_abs_tendsto_zero
File: Mathlib/Topology/Algebra/Order/Group.lean

tactic: refine' ⟨fun h => (abs_zero : |(0 : G)| = 0) ▸ h.abs, fun h => _⟩
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
⊢ Tendsto f l (𝓝 0) ↔ Tendsto (abs ∘ f) l (𝓝 0)

tactic: have : Tendsto (fun a => -|f a|) l (𝓝 0) := (neg_zero : -(0 : G) = 0) ▸ h.neg
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)

tactic: exact
  tendsto_of_tendsto_of_tendsto_of_le_of_le this h (fun x => neg_abs_le_self <| f x) fun x =>
    le_abs_self <| f x
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
this : Tendsto (fun a => -abs (f a)) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)
Theorem: Subtype.coe_image_subset
File: Mathlib/Data/Set/Image.lean

tactic: rw [← yvaleq]
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ x ∈ s

tactic: exact y.property
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ ↑y ∈ s
Theorem: essSup_map_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: rw [essSup_congr_ae hg.ae_eq_mk, essSup_map_measure_of_measurable hg.measurable_mk hf]
state_before: α : Type u_3
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝⁵ : CompleteLattice β
γ : Type u_1
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : SecondCountableTopology β
inst✝¹ : OrderClosedTopology β
inst✝ : OpensMeasurableSpace β
hg : AEMeasurable g
hf : AEMeasurable f
⊢ essSup g (Measure.map f μ) = essSup (g ∘ f) μ

tactic: refine' essSup_congr_ae _
state_before: α : Type u_3
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝⁵ : CompleteLattice β
γ : Type u_1
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : SecondCountableTopology β
inst✝¹ : OrderClosedTopology β
inst✝ : OpensMeasurableSpace β
hg : AEMeasurable g
hf : AEMeasurable f
⊢ essSup (AEMeasurable.mk g hg ∘ f) μ = essSup (g ∘ f) μ

tactic: have h_eq := ae_of_ae_map hf hg.ae_eq_mk
state_before: α : Type u_3
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝⁵ : CompleteLattice β
γ : Type u_1
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : SecondCountableTopology β
inst✝¹ : OrderClosedTopology β
inst✝ : OpensMeasurableSpace β
hg : AEMeasurable g
hf : AEMeasurable f
⊢ AEMeasurable.mk g hg ∘ f =ᵐ[μ] g ∘ f

tactic: rw [← EventuallyEq] at h_eq
state_before: α : Type u_3
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝⁵ : CompleteLattice β
γ : Type u_1
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : SecondCountableTopology β
inst✝¹ : OrderClosedTopology β
inst✝ : OpensMeasurableSpace β
hg : AEMeasurable g
hf : AEMeasurable f
h_eq : ∀ᵐ (x : α) ∂μ, g (f x) = AEMeasurable.mk g hg (f x)
⊢ AEMeasurable.mk g hg ∘ f =ᵐ[μ] g ∘ f

tactic: exact h_eq.symm
state_before: α : Type u_3
β : Type u_2
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
inst✝⁵ : CompleteLattice β
γ : Type u_1
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : SecondCountableTopology β
inst✝¹ : OrderClosedTopology β
inst✝ : OpensMeasurableSpace β
hg : AEMeasurable g
hf : AEMeasurable f
h_eq : (fun x => g (f x)) =ᵐ[μ] fun x => AEMeasurable.mk g hg (f x)
⊢ AEMeasurable.mk g hg ∘ f =ᵐ[μ] g ∘ f
Theorem: CategoryTheory.tensorLeftHomEquiv_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : Y' ⊗ X ⟶ Z
g : Z ⟶ Z'
⊢ ↑(tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = ↑(tensorLeftHomEquiv X Y Y' Z) f ≫ (𝟙 Y ⊗ g)

tactic: simp only [id_tensor_comp, Category.assoc]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : Y' ⊗ X ⟶ Z
g : Z ⟶ Z'
⊢ (λ_ X).inv ≫ (η_ Y Y' ⊗ 𝟙 X) ≫ (α_ Y Y' X).hom ≫ (𝟙 Y ⊗ f ≫ g) =
    ((λ_ X).inv ≫ (η_ Y Y' ⊗ 𝟙 X) ≫ (α_ Y Y' X).hom ≫ (𝟙 Y ⊗ f)) ≫ (𝟙 Y ⊗ g)
Theorem: CategoryTheory.Limits.limit.pre_pre
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: haveI : HasLimit ((D ⋙  E) ⋙  F) := h
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasLimit F
E : K ⥤ J
inst✝² : HasLimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)

tactic: ext j
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasLimit F
E : K ⥤ J
inst✝² : HasLimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)

tactic: erw [assoc, limit.pre_π, limit.pre_π, limit.pre_π]
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasLimit F
E : K ⥤ J
inst✝² : HasLimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ (pre F E ≫ pre (E ⋙ F) D) ≫ π (D ⋙ E ⋙ F) j = pre F (D ⋙ E) ≫ π (D ⋙ E ⋙ F) j

tactic: rfl
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasLimit F
E : K ⥤ J
inst✝² : HasLimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ π F (E.obj (D.obj j)) = π F ((D ⋙ E).obj j)
Theorem: Associates.count_eq_zero_of_ne
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
p q : Associates α
hp : Irreducible p
hq : Irreducible q
h : p ≠ q
h' : count p (factors q) ≠ 0
⊢ p ∣ q

tactic: exact le_of_count_ne_zero hq.ne_zero hp h'
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
p q : Associates α
hp : Irreducible p
hq : Irreducible q
h : p ≠ q
h' : count p (factors q) ≠ 0
✝ : Nontrivial α
⊢ p ∣ q
Theorem: FixedPoints.finrank_le_card
File: Mathlib/FieldTheory/Fixed.lean

tactic: rw [← Cardinal.natCast_le, finrank_eq_rank]
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
⊢ finrank { x // x ∈ subfield G F } F ≤ Fintype.card G

tactic: apply rank_le_card
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
⊢ Module.rank { x // x ∈ subfield G F } F ≤ ↑(Fintype.card G)
Theorem: CategoryTheory.Subobject.inf_arrow_factors_right
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
B : C
X Y : Subobject B
⊢ ofLE (X ⊓ Y) Y (_ : (inf.obj X).obj Y ≤ Y) ≫ MonoOver.arrow (representative.obj Y) = arrow (X ⊓ Y)
Theorem: UniversalEnvelopingAlgebra.lift_unique
File: Mathlib/Algebra/Lie/UniversalEnveloping.lean

tactic: refine' Iff.trans _ (lift R).symm_apply_eq
state_before: R : Type u₁
L : Type u₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u₃
inst✝¹ : Ring A
inst✝ : Algebra R A
f : L →ₗ⁅R⁆ A
g : UniversalEnvelopingAlgebra R L →ₐ[R] A
⊢ ↑g ∘ ↑(ι R) = ↑f ↔ g = ↑(lift R) f

tactic: intro h
state_before: case mpr
R : Type u₁
L : Type u₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u₃
inst✝¹ : Ring A
inst✝ : Algebra R A
f : L →ₗ⁅R⁆ A
g : UniversalEnvelopingAlgebra R L →ₐ[R] A
⊢ ↑(lift R).symm g = f → ↑g ∘ ↑(ι R) = ↑f

tactic: ext
state_before: case mpr
R : Type u₁
L : Type u₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u₃
inst✝¹ : Ring A
inst✝ : Algebra R A
f : L →ₗ⁅R⁆ A
g : UniversalEnvelopingAlgebra R L →ₐ[R] A
h : ↑(lift R).symm g = f
⊢ ↑g ∘ ↑(ι R) = ↑f

tactic: simp [← h]
state_before: case mpr.h
R : Type u₁
L : Type u₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
A : Type u₃
inst✝¹ : Ring A
inst✝ : Algebra R A
f : L →ₗ⁅R⁆ A
g : UniversalEnvelopingAlgebra R L →ₐ[R] A
h : ↑(lift R).symm g = f
x✝ : L
⊢ (↑g ∘ ↑(ι R)) x✝ = ↑f x✝
Theorem: AList.insert_entries_of_neg
File: Mathlib/Data/List/AList.lean

tactic: rw [insert_entries, kerase_of_not_mem_keys h]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
h : ¬a ∈ s
⊢ (insert a b s).entries = { fst := a, snd := b } :: s.entries
Theorem: FreeRing.induction_on
File: Mathlib/RingTheory/FreeRing.lean

tactic: convert hm _ _ (hb a) ih
state_before: α : Type u
C : FreeRing α → Prop
z : FreeRing α
hn1 : C (-1)
hb : ∀ (b : α), C (of b)
ha : ∀ (x y : FreeRing α), C x → C y → C (x + y)
hm : ∀ (x y : FreeRing α), C x → C y → C (x * y)
hn : ∀ (x : FreeRing α), C x → C (-x)
h1 : C 1
m✝ : FreeMonoid α
a : α
m : List α
ih : C (FreeAbelianGroup.of m)
⊢ C (FreeAbelianGroup.of (a :: m))

tactic: rw [of, ← FreeAbelianGroup.of_mul]
state_before: case h.e'_1
α : Type u
C : FreeRing α → Prop
z : FreeRing α
hn1 : C (-1)
hb : ∀ (b : α), C (of b)
ha : ∀ (x y : FreeRing α), C x → C y → C (x + y)
hm : ∀ (x y : FreeRing α), C x → C y → C (x * y)
hn : ∀ (x : FreeRing α), C x → C (-x)
h1 : C 1
m✝ : FreeMonoid α
a : α
m : List α
ih : C (FreeAbelianGroup.of m)
⊢ FreeAbelianGroup.of (a :: m) = of a * FreeAbelianGroup.of m

tactic: rfl
state_before: case h.e'_1
α : Type u
C : FreeRing α → Prop
z : FreeRing α
hn1 : C (-1)
hb : ∀ (b : α), C (of b)
ha : ∀ (x y : FreeRing α), C x → C y → C (x + y)
hm : ∀ (x y : FreeRing α), C x → C y → C (x * y)
hn : ∀ (x : FreeRing α), C x → C (-x)
h1 : C 1
m✝ : FreeMonoid α
a : α
m : List α
ih : C (FreeAbelianGroup.of m)
⊢ FreeAbelianGroup.of (a :: m) = FreeAbelianGroup.of (FreeMonoid.of a * m)
Theorem: BoxIntegral.HasIntegral.neg
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [HasIntegral, ← integralSum_neg] using hf.neg
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hf : HasIntegral I l f vol y
⊢ HasIntegral I l (-f) vol (-y)