1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AlgebraicGeometry.Scheme.app_eq
File: Mathlib/AlgebraicGeometry/Scheme.lean

tactic: rw [← IsIso.inv_comp_eq, ← Functor.map_inv, f.val.c.naturality, Presheaf.pushforwardObj_map]
state_before: X Y : Scheme
f : X ⟶ Y
U V : Opens ↑↑Y.toPresheafedSpace
e : U = V
⊢ Hom.app f U = Y.presheaf.map (eqToHom ⋯).op ≫ Hom.app f V ≫ X.presheaf.map (eqToHom ⋯).op
state_after: X Y : Scheme
f : X ⟶ Y
U V : Opens ↑↑Y.toPresheafedSpace
e : U = V
⊢ f.val.c.app { unop := V } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (inv (eqToHom ⋯).op)) =
    Hom.app f V ≫ X.presheaf.map (eqToHom ⋯).op

tactic: cases e
state_before: X Y : Scheme
f : X ⟶ Y
U V : Opens ↑↑Y.toPresheafedSpace
e : U = V
⊢ f.val.c.app { unop := V } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (inv (eqToHom ⋯).op)) =
    Hom.app f V ≫ X.presheaf.map (eqToHom ⋯).op
state_after: case refl
X Y : Scheme
f : X ⟶ Y
U : Opens ↑↑Y.toPresheafedSpace
⊢ f.val.c.app { unop := U } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (inv (eqToHom ⋯).op)) =
    Hom.app f U ≫ X.presheaf.map (eqToHom ⋯).op

tactic: rfl
state_before: case refl
X Y : Scheme
f : X ⟶ Y
U : Opens ↑↑Y.toPresheafedSpace
⊢ f.val.c.app { unop := U } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (inv (eqToHom ⋯).op)) =
    Hom.app f U ≫ X.presheaf.map (eqToHom ⋯).op
state_after: no goals
Theorem: Nat.dist_eq_max_sub_min
File: Mathlib/Data/Nat/Dist.lean

tactic: intro h
state_before: i j : ℕ
⊢ i < j → i.dist j = max i j - min i j
state_after: i j : ℕ
h : i < j
⊢ i.dist j = max i j - min i j

tactic: rw [max_eq_right_of_lt h, min_eq_left_of_lt h, dist_eq_sub_of_le (Nat.le_of_lt h)]
state_before: i j : ℕ
h : i < j
⊢ i.dist j = max i j - min i j
state_after: no goals

tactic: intro h
state_before: i j : ℕ
⊢ i ≥ j → i.dist j = max i j - min i j
state_after: i j : ℕ
h : i ≥ j
⊢ i.dist j = max i j - min i j

tactic: rw [max_eq_left h, min_eq_right h, dist_eq_sub_of_le_right h]
state_before: i j : ℕ
h : i ≥ j
⊢ i.dist j = max i j - min i j
state_after: no goals
Theorem: Multiset.bind_map
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : β → Multiset γ
f : α → β
⊢ (map f 0).bind n = bind 0 fun a => n (f a)
state_after: no goals

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : β → Multiset γ
f : α → β
⊢ ∀ (a : α) (s : Multiset α),
    ((map f s).bind n = s.bind fun a => n (f a)) → (map f (a ::ₘ s)).bind n = (a ::ₘ s).bind fun a => n (f a)
state_after: no goals
Theorem: Set.preimage_add_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [add_comm] using preimage_const_add_uIcc a b c
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => x + a) ⁻¹' [[b, c]] = [[b - a, c - a]]
state_after: no goals
Theorem: Matroid.uniqueBaseOn_dual_eq
File: Mathlib/Data/Matroid/Constructions.lean

tactic: rw [← uniqueBaseOn_inter_ground_eq]
state_before: α : Type u_1
M : Matroid α
E✝ B I✝ X R J I E : Set α
⊢ (uniqueBaseOn I E)✶ = uniqueBaseOn (E \ I) E
state_after: α : Type u_1
M : Matroid α
E✝ B I✝ X R J I E : Set α
⊢ (uniqueBaseOn (I ∩ E) E)✶ = uniqueBaseOn (E \ I) E

tactic: refine eq_of_base_iff_base_forall rfl (fun B (hB : B ⊆ E) ↦ ?_)
state_before: α : Type u_1
M : Matroid α
E✝ B I✝ X R J I E : Set α
⊢ (uniqueBaseOn (I ∩ E) E)✶ = uniqueBaseOn (E \ I) E
state_after: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
⊢ (uniqueBaseOn (I ∩ E) E)✶.Base B ↔ (uniqueBaseOn (E \ I) E).Base B

tactic: rw [dual_base_iff, uniqueBaseOn_base_iff inter_subset_right, uniqueBaseOn_base_iff diff_subset,
  uniqueBaseOn_ground]
state_before: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
⊢ (uniqueBaseOn (I ∩ E) E)✶.Base B ↔ (uniqueBaseOn (E \ I) E).Base B
state_after: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
⊢ E \ B = I ∩ E ↔ B = E \ I

tactic: exact ⟨fun h ↦ by rw [← diff_diff_cancel_left hB, h, diff_inter_self_eq_diff],
  fun h ↦ by rw [h, inter_comm I]; simp⟩
state_before: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
⊢ E \ B = I ∩ E ↔ B = E \ I
state_after: no goals

tactic: rw [← diff_diff_cancel_left hB, h, diff_inter_self_eq_diff]
state_before: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
h : E \ B = I ∩ E
⊢ B = E \ I
state_after: no goals

tactic: rw [h, inter_comm I]
state_before: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
h : B = E \ I
⊢ E \ B = I ∩ E
state_after: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
h : B = E \ I
⊢ E \ (E \ I) = E ∩ I

tactic: simp
state_before: α : Type u_1
M : Matroid α
E✝ B✝ I✝ X R J I E B : Set α
hB : B ⊆ E
h : B = E \ I
⊢ E \ (E \ I) = E ∩ I
state_after: no goals
Theorem: bihimp_bihimp_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp_comm, bihimp_bihimp_cancel_left]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ b ⇔ a = b
state_after: no goals
Theorem: Finset.Shatters.mono_right
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

tactic: obtain ⟨v, hv, rfl⟩ := hs (hu.trans h)
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : t ⊆ s
hs : 𝒜.Shatters s
u : Finset α
hu : u ⊆ t
⊢ ∃ u_1 ∈ 𝒜, t ∩ u_1 = u
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : t ⊆ s
hs : 𝒜.Shatters s
v : Finset α
hv : v ∈ 𝒜
hu : s ∩ v ⊆ t
⊢ ∃ u ∈ 𝒜, t ∩ u = s ∩ v

tactic: exact ⟨v, hv, inf_congr_right hu <| inf_le_of_left_le h⟩
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : t ⊆ s
hs : 𝒜.Shatters s
v : Finset α
hv : v ∈ 𝒜
hu : s ∩ v ⊆ t
⊢ ∃ u ∈ 𝒜, t ∩ u = s ∩ v
state_after: no goals
Theorem: Rat.div_def'
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [← divInt_div_divInt, num_divInt_den, num_divInt_den]
state_before: q✝ q r : ℚ
⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)
state_after: no goals
Theorem: Filter.lift'_pure
File: Mathlib/Order/Filter/Lift.lean

tactic: rw [← principal_singleton, lift'_principal hh]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
a : α
hh : Monotone h
⊢ (pure a).lift' h = 𝓟 (h {a})
state_after: no goals
Theorem: Inducing.tendsto_nhds_iff
File: Mathlib/Topology/Maps.lean

tactic: rw [hg.nhds_eq_comap, tendsto_comap_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f✝ : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : ι → Y
l : Filter ι
y : Y
hg : Inducing g
⊢ Tendsto f l (𝓝 y) ↔ Tendsto (g ∘ f) l (𝓝 (g y))
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.whiskerRight_naturality_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: rw [← comp_whiskerRight, naturality_naturality, comp_whiskerRight, whisker_assoc]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f g : a ⟶ b
β : f ⟶ g
h : (↑G.toPrelaxFunctor).obj b ⟶ a'
⊢ F.map₂ β ▷ η.app b ▷ h ≫ η.naturality g ▷ h =
    η.naturality f ▷ h ≫
      (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) h).hom ≫
        η.app a ◁ G.map₂ β ▷ h ≫ (α_ (η.app a) ((↑G.toPrelaxFunctor).map g) h).inv
state_after: no goals
Theorem: PicardLindelof.dist_t₀_le
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: rw [Subtype.dist_eq, Real.dist_eq]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ dist t v.t₀ ≤ v.tDist
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ |↑t - ↑v.t₀| ≤ v.tDist

tactic: rcases le_total t v.t₀ with ht | ht
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ |↑t - ↑v.t₀| ≤ v.tDist
state_after: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ |↑t - ↑v.t₀| ≤ v.tDist

case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ |↑t - ↑v.t₀| ≤ v.tDist

tactic: rw [abs_of_nonpos (sub_nonpos.2 <| Subtype.coe_le_coe.2 ht), neg_sub]
state_before: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ |↑t - ↑v.t₀| ≤ v.tDist
state_after: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ ↑v.t₀ - ↑t ≤ v.tDist

tactic: exact (sub_le_sub_left t.2.1 _).trans (le_max_right _ _)
state_before: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ ↑v.t₀ - ↑t ≤ v.tDist
state_after: no goals

tactic: rw [abs_of_nonneg (sub_nonneg.2 <| Subtype.coe_le_coe.2 ht)]
state_before: case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ |↑t - ↑v.t₀| ≤ v.tDist
state_after: case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ ↑t - ↑v.t₀ ≤ v.tDist

tactic: exact (sub_le_sub_right t.2.2 _).trans (le_max_left _ _)
state_before: case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ ↑t - ↑v.t₀ ≤ v.tDist
state_after: no goals
Theorem: Complex.neg_ofReal_mem_slitPlane
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa using ofReal_mem_slitPlane (x := -x)
state_before: x : ℝ
⊢ -↑x ∈ slitPlane ↔ x < 0
state_after: no goals
Theorem: LieIdeal.incl_isIdealMorphism
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [I.incl.isIdealMorphism_def, incl_idealRange]
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 : LieIdeal R L
J : LieIdeal R L'
⊢ I.incl.IsIdealMorphism
state_after: 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 : LieIdeal R L
J : LieIdeal R L'
⊢ lieIdealSubalgebra R L I = I.incl.range

tactic: exact (I : LieSubalgebra R L).incl_range.symm
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 : LieIdeal R L
J : LieIdeal R L'
⊢ lieIdealSubalgebra R L I = I.incl.range
state_after: no goals
Theorem: Int.preimage_Ioo
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ Int.cast ⁻¹' Ioo a b = Ioo ⌊a⌋ ⌈b⌉
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioo a b ↔ x✝ ∈ Ioo ⌊a⌋ ⌈b⌉

tactic: simp [floor_lt, lt_ceil]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioo a b ↔ x✝ ∈ Ioo ⌊a⌋ ⌈b⌉
state_after: no goals
Theorem: LinearMap.BilinForm.congr_symm
File: Mathlib/LinearAlgebra/BilinearForm/Hom.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
e : M ≃ₗ[R] M'
⊢ (congr e).symm = congr e.symm
state_after: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
e : M ≃ₗ[R] M'
x✝¹ : BilinForm R M'
x✝ y✝ : M
⊢ (((congr e).symm x✝¹) x✝) y✝ = (((congr e.symm) x✝¹) x✝) y✝

tactic: simp only [congr_apply, LinearEquiv.symm_symm]
state_before: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
e : M ≃ₗ[R] M'
x✝¹ : BilinForm R M'
x✝ y✝ : M
⊢ (((congr e).symm x✝¹) x✝) y✝ = (((congr e.symm) x✝¹) x✝) y✝
state_after: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
e : M ≃ₗ[R] M'
x✝¹ : BilinForm R M'
x✝ y✝ : M
⊢ (((congr e).symm x✝¹) x✝) y✝ = (x✝¹ (e x✝)) (e y✝)

tactic: rfl
state_before: case h.H
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
e : M ≃ₗ[R] M'
x✝¹ : BilinForm R M'
x✝ y✝ : M
⊢ (((congr e).symm x✝¹) x✝) y✝ = (x✝¹ (e x✝)) (e y✝)
state_after: no goals
Theorem: Polynomial.Monic.not_dvd_of_natDegree_lt
File: Mathlib/Algebra/Polynomial/Monic.lean

tactic: rintro ⟨r, rfl⟩
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h0 : q ≠ 0
hl : q.natDegree < p.natDegree
⊢ ¬p ∣ q
state_after: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r✝ : R[X]
hp : p.Monic
r : R[X]
h0 : p * r ≠ 0
hl : (p * r).natDegree < p.natDegree
⊢ False

tactic: rw [hp.natDegree_mul' <| right_ne_zero_of_mul h0] at hl
state_before: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r✝ : R[X]
hp : p.Monic
r : R[X]
h0 : p * r ≠ 0
hl : (p * r).natDegree < p.natDegree
⊢ False
state_after: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r✝ : R[X]
hp : p.Monic
r : R[X]
h0 : p * r ≠ 0
hl : p.natDegree + r.natDegree < p.natDegree
⊢ False

tactic: exact hl.not_le (Nat.le_add_right _ _)
state_before: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r✝ : R[X]
hp : p.Monic
r : R[X]
h0 : p * r ≠ 0
hl : p.natDegree + r.natDegree < p.natDegree
⊢ False
state_after: no goals
Theorem: EReal.abs_neg
File: Mathlib/Data/Real/EReal.lean

tactic: rw [abs_def, ← coe_neg, abs_def, abs_neg]
state_before: x : ℝ
⊢ (-↑x).abs = (↑x).abs
state_after: no goals
Theorem: Ordinal.apply_le_nfpFamily
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: refine ⟨fun h => ?_, fun h i => ?_⟩
state_before: ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (∀ (i : ι), f i b ≤ nfpFamily f a) ↔ b ≤ nfpFamily f a
state_after: case refine_1
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
⊢ b ≤ nfpFamily f a

case refine_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ nfpFamily f a

tactic: rw [← nfpFamily_fp (H i)]
state_before: case refine_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ nfpFamily f a
state_after: case refine_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ f i (nfpFamily f a)

tactic: exact (H i).monotone h
state_before: case refine_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ f i (nfpFamily f a)
state_after: no goals

tactic: cases' hι with i
state_before: case refine_1
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
⊢ b ≤ nfpFamily f a
state_after: case refine_1.intro
ι : Type u
f✝ f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
i : ι
⊢ b ≤ nfpFamily f a

tactic: exact ((H i).self_le b).trans (h i)
state_before: case refine_1.intro
ι : Type u
f✝ f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
i : ι
⊢ b ≤ nfpFamily f a
state_after: no goals
Theorem: WithTop.map_add
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: induction a
state_before: α : Type u
β : Type v
inst✝³ : Add α
a✝ b✝ c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a b : WithTop α
⊢ map (⇑f) (a + b) = map (⇑f) a + map (⇑f) b
state_after: case top
α : Type u
β : Type v
inst✝³ : Add α
a b✝ c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
b : WithTop α
⊢ map (⇑f) (⊤ + b) = map ⇑f ⊤ + map (⇑f) b

case coe
α : Type u
β : Type v
inst✝³ : Add α
a b✝ c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
b : WithTop α
a✝ : α
⊢ map (⇑f) (↑a✝ + b) = map ⇑f ↑a✝ + map (⇑f) b

tactic: exact (top_add _).symm
state_before: case top
α : Type u
β : Type v
inst✝³ : Add α
a b✝ c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
b : WithTop α
⊢ map (⇑f) (⊤ + b) = map ⇑f ⊤ + map (⇑f) b
state_after: no goals

tactic: induction b
state_before: case coe
α : Type u
β : Type v
inst✝³ : Add α
a b✝ c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
b : WithTop α
a✝ : α
⊢ map (⇑f) (↑a✝ + b) = map ⇑f ↑a✝ + map (⇑f) b
state_after: case coe.top
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝ : α
⊢ map (⇑f) (↑a✝ + ⊤) = map ⇑f ↑a✝ + map ⇑f ⊤

case coe.coe
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝¹ a✝ : α
⊢ map (⇑f) (↑a✝¹ + ↑a✝) = map ⇑f ↑a✝¹ + map ⇑f ↑a✝

tactic: exact (add_top _).symm
state_before: case coe.top
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝ : α
⊢ map (⇑f) (↑a✝ + ⊤) = map ⇑f ↑a✝ + map ⇑f ⊤
state_after: no goals

tactic: rw [map_coe, map_coe, ← coe_add, ← coe_add, ← map_add]
state_before: case coe.coe
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝¹ a✝ : α
⊢ map (⇑f) (↑a✝¹ + ↑a✝) = map ⇑f ↑a✝¹ + map ⇑f ↑a✝
state_after: case coe.coe
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝¹ a✝ : α
⊢ map ⇑f ↑(a✝¹ + a✝) = ↑(f (a✝¹ + a✝))

tactic: rfl
state_before: case coe.coe
α : Type u
β : Type v
inst✝³ : Add α
a b c d : WithTop α
x y : α
F : Type u_1
inst✝² : Add β
inst✝¹ : FunLike F α β
inst✝ : AddHomClass F α β
f : F
a✝¹ a✝ : α
⊢ map ⇑f ↑(a✝¹ + a✝) = ↑(f (a✝¹ + a✝))
state_after: no goals
Theorem: continuousAt_dslope_same
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: simp only [dslope, continuousAt_update_same, ← hasDerivAt_deriv_iff, hasDerivAt_iff_tendsto_slope]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
⊢ ContinuousAt (dslope f a) a ↔ DifferentiableAt 𝕜 f a
state_after: no goals
Theorem: rTensor.inverse_apply
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

tactic: rw [rTensor.inverse, rTensor.inverse_of_rightInverse_apply]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
y : N ⊗[R] Q
⊢ (inverse Q hfg hg) ((rTensor Q g) y) = Submodule.Quotient.mk y
state_after: no goals