tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degree_lt_degree_mul_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: haveI := Nontrivial.of_polynomial_ne hp
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.707375
hp : p ≠ 0
⊢ degree p < degree (p * X)

tactic: have : leadingCoeff p * leadingCoeff X ≠ 0 := by simpa
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.707375
hp : p ≠ 0
this : Nontrivial R
⊢ degree p < degree (p * X)

tactic: erw [degree_mul' this, degree_eq_natDegree hp, degree_X, ← WithBot.coe_one,
  ← WithBot.coe_add, WithBot.coe_lt_coe]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.707375
hp : p ≠ 0
this✝ : Nontrivial R
this : leadingCoeff p * leadingCoeff X ≠ 0
⊢ degree p < degree (p * X)

tactic: exact Nat.lt_succ_self _
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.707375
hp : p ≠ 0
this✝ : Nontrivial R
this : leadingCoeff p * leadingCoeff X ≠ 0
⊢ ↑(natDegree p) < ↑(natDegree p) + 1

tactic: simpa
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.707375
hp : p ≠ 0
this : Nontrivial R
⊢ leadingCoeff p * leadingCoeff X ≠ 0
Theorem: MeasureTheory.SimpleFunc.simpleFunc_bot'
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: letI : MeasurableSpace α := ⊥
state_before: α✝ : Type ?u.21990
β : Type u_2
γ : Type ?u.21996
δ : Type ?u.21999
inst✝¹ : MeasurableSpace α✝
α : Type u_1
inst✝ : Nonempty β
f : α →ₛ β
⊢ ∃ c, f = const α c

tactic: obtain ⟨c, h_eq⟩ := simpleFunc_bot f
state_before: α✝ : Type ?u.21990
β : Type u_2
γ : Type ?u.21996
δ : Type ?u.21999
inst✝¹ : MeasurableSpace α✝
α : Type u_1
inst✝ : Nonempty β
f : α →ₛ β
this : MeasurableSpace α := ⊥
⊢ ∃ c, f = const α c

tactic: refine' ⟨c, _⟩
state_before: case intro
α✝ : Type ?u.21990
β : Type u_2
γ : Type ?u.21996
δ : Type ?u.21999
inst✝¹ : MeasurableSpace α✝
α : Type u_1
inst✝ : Nonempty β
f : α →ₛ β
this : MeasurableSpace α := ⊥
c : β
h_eq : ∀ (x : α), ↑f x = c
⊢ ∃ c, f = const α c

tactic: ext1 x
state_before: case intro
α✝ : Type ?u.21990
β : Type u_2
γ : Type ?u.21996
δ : Type ?u.21999
inst✝¹ : MeasurableSpace α✝
α : Type u_1
inst✝ : Nonempty β
f : α →ₛ β
this : MeasurableSpace α := ⊥
c : β
h_eq : ∀ (x : α), ↑f x = c
⊢ f = const α c

tactic: rw [h_eq x, SimpleFunc.coe_const, Function.const]
state_before: case intro.H
α✝ : Type ?u.21990
β : Type u_2
γ : Type ?u.21996
δ : Type ?u.21999
inst✝¹ : MeasurableSpace α✝
α : Type u_1
inst✝ : Nonempty β
f : α →ₛ β
this : MeasurableSpace α := ⊥
c : β
h_eq : ∀ (x : α), ↑f x = c
x : α
⊢ ↑f x = ↑(const α c) x
Theorem: Int.ofNat_natAbs_of_nonpos
File: Std/Data/Int/Lemmas.lean

tactic: rw [← natAbs_neg, natAbs_of_nonneg (Int.neg_nonneg_of_nonpos H)]
state_before: a : Int
H : a ≤ 0
⊢ ↑(natAbs a) = -a
Theorem: CategoryTheory.Presieve.isSheaf_bot
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: simp [isSheafFor_top_sieve]
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
J J₂ : GrothendieckTopology C
X : C
⊢ ∀ (S : Sieve X), S ∈ GrothendieckTopology.sieves ⊥ X → IsSheafFor P S.arrows
Theorem: Quiver.Hom.cast_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
⊢ HEq (cast hu hv e) e

tactic: rfl
state_before: U : Type u_1
inst✝ : Quiver U
u' v' : U
e : u' ⟶ v'
⊢ HEq (cast (_ : u' = u') (_ : v' = v') e) e
Theorem: Int.add_mul_emod_self_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.add_mul_emod_self]
state_before: a b c : Int
⊢ (a + b * c) % b = a % b
Theorem: Filter.comap_neBot_iff_frequently
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [comap_neBot_iff, frequently_iff, mem_range, @and_comm (_ ∈ _), exists_exists_eq_and]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.263265
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ NeBot (comap m f) ↔ ∃ᶠ (y : β) in f, y ∈ range m
Theorem: CategoryTheory.Limits.WidePullback.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: intro h1 h2
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
⊢ (∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j) → g1 ≫ base arrows = g2 ≫ base arrows → g1 = g2

tactic: apply limit.hom_ext
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 = g2

tactic: rintro (_ | _)
state_before: case w
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ ∀ (j : WidePullbackShape J),
    g1 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) j =
      g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) j

tactic: apply h2
state_before: case w.none
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) none =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) none

tactic: apply h1
state_before: case w.some
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
val✝ : J
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) (some val✝) =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) (some val✝)
Theorem: Std.RBNode.Path.fill_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: induction p generalizing t <;> simp [*]
state_before: α : Type u_1
t : RBNode α
p : Path α
⊢ toList (fill p t) = withList p (toList t)
Theorem: WithZeroTopology.isClosed_iff
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: simp only [← isOpen_compl_iff, isOpen_iff, mem_compl_iff, not_not, ← compl_Ici,
  compl_subset_compl]
state_before: α : Type ?u.91489
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ IsClosed s ↔ 0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ s ⊆ Ici γ
Theorem: Fin.update_cons_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
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
⊢ update (cons x p) 0 z = cons z p

tactic: by_cases h : j = 0
state_before: case h
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
j : Fin (n + 1)
⊢ update (cons x p) 0 z j = cons z p j

tactic: rw [h]
state_before: case pos
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
j : Fin (n + 1)
h : j = 0
⊢ update (cons x p) 0 z j = cons z p j

tactic: simp
state_before: case pos
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
j : Fin (n + 1)
h : j = 0
⊢ update (cons x p) 0 z 0 = cons z p 0

tactic: simp only [h, update_noteq, Ne.def, not_false_iff]
state_before: case neg
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
j : Fin (n + 1)
h : ¬j = 0
⊢ update (cons x p) 0 z j = cons z p j

tactic: let j' := pred j h
state_before: case neg
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
j : Fin (n + 1)
h : ¬j = 0
⊢ cons x p j = cons z p j

tactic: have : j'.succ = j := succ_pred j h
state_before: case neg
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
j : Fin (n + 1)
h : ¬j = 0
j' : Fin n := pred j h
⊢ cons x p j = cons z p j

tactic: rw [← this, cons_succ, cons_succ]
state_before: case neg
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
j : Fin (n + 1)
h : ¬j = 0
j' : Fin n := pred j h
this : succ j' = j
⊢ cons x p j = cons z p j
Theorem: Finsupp.mapDomain_equiv_apply
File: Mathlib/Data/Finsupp/Basic.lean

tactic: conv_lhs => rw [← f.apply_symm_apply a]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172677
ι : Type ?u.172680
M : Type u_3
M' : Type ?u.172686
N : Type ?u.172689
P : Type ?u.172692
G : Type ?u.172695
H : Type ?u.172698
R : Type ?u.172701
S : Type ?u.172704
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α ≃ β
x : α →₀ M
a : β
⊢ ↑(mapDomain (↑f) x) a = ↑x (↑f.symm a)

tactic: exact mapDomain_apply f.injective _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172677
ι : Type ?u.172680
M : Type u_3
M' : Type ?u.172686
N : Type ?u.172689
P : Type ?u.172692
G : Type ?u.172695
H : Type ?u.172698
R : Type ?u.172701
S : Type ?u.172704
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
f : α ≃ β
x : α →₀ M
a : β
⊢ ↑(mapDomain (↑f) x) (↑f (↑f.symm a)) = ↑x (↑f.symm a)
Theorem: Basis.toDual_inj
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← mem_bot R, ← b.repr.ker, mem_ker, LinearEquiv.coe_coe]
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
m : M
a : ↑(toDual b) m = 0
⊢ m = 0

tactic: apply Finsupp.ext
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
m : M
a : ↑(toDual b) m = 0
⊢ ↑b.repr m = 0

tactic: intro b
state_before: case h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
m : M
a : ↑(toDual b) m = 0
⊢ ∀ (a : ι), ↑(↑b.repr m) a = ↑0 a

tactic: rw [← toDual_eq_repr, a]
state_before: case h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b✝ : Basis ι R M
m : M
a : ↑(toDual b✝) m = 0
b : ι
⊢ ↑(↑b✝.repr m) b = ↑0 b

tactic: rfl
state_before: case h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b✝ : Basis ι R M
m : M
a : ↑(toDual b✝) m = 0
b : ι
⊢ ↑0 (↑b✝ b) = ↑0 b
Theorem: AffineSubspace.isClosed_direction_iff
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rcases s.eq_bot_or_nonempty with (rfl | ⟨x, hx⟩)
state_before: α : Type ?u.597
V : Type ?u.600
P : Type ?u.603
W : Type u_2
Q : Type u_3
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
⊢ IsClosed ↑(direction s) ↔ IsClosed ↑s

tactic: rw [← (IsometryEquiv.vaddConst x).toHomeomorph.symm.isClosed_image,
  AffineSubspace.coe_direction_eq_vsub_set_right hx]
state_before: case inr.intro
α : Type ?u.597
V : Type ?u.600
P : Type ?u.603
W : Type u_2
Q : Type u_3
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ↑(direction s) ↔ IsClosed ↑s

tactic: rfl
state_before: case inr.intro
α : Type ?u.597
V : Type ?u.600
P : Type ?u.603
W : Type u_2
Q : Type u_3
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ((fun x_1 => x_1 -ᵥ x) '' ↑s) ↔
    IsClosed (↑(Homeomorph.symm (IsometryEquiv.toHomeomorph (IsometryEquiv.vaddConst x))) '' ↑s)

tactic: simp [isClosed_singleton]
state_before: case inl
α : Type ?u.597
V : Type ?u.600
P : Type ?u.603
W : Type u_2
Q : Type u_3
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
⊢ IsClosed ↑(direction ⊥) ↔ IsClosed ↑⊥
Theorem: homTensorHomEquiv_toLinearMap
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext (m n)
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
inst✝¹² : AddCommGroup M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : AddCommGroup Q
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ ↑(homTensorHomEquiv R M N P Q) = homTensorHomMap R M N P Q

tactic: simp only [homTensorHomEquiv, compr₂_apply, mk_apply, LinearEquiv.coe_toLinearMap,
  LinearEquiv.trans_apply, lift.equiv_apply, LinearEquiv.arrowCongr_apply, LinearEquiv.refl_symm,
  LinearEquiv.refl_apply, rTensorHomEquivHomRTensor_apply, lTensorHomEquivHomLTensor_apply,
  lTensorHomToHomLTensor_apply, rTensorHomToHomRTensor_apply, homTensorHomMap_apply,
  map_tmul]
state_before: case H.h.h.H.h.h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
inst✝¹² : AddCommGroup M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : AddCommGroup P
inst✝⁹ : AddCommGroup Q
inst✝⁸ : Module R M
inst✝⁷ : Module R N
inst✝⁶ : Module R P
inst✝⁵ : Module R Q
inst✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
m : M →ₗ[R] P
n : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ ↑(↑(compr₂ (TensorProduct.mk R M N)
              (↑(↑(compr₂ (TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)) ↑(homTensorHomEquiv R M N P Q)) m) n))
          x✝¹)
      x✝ =
    ↑(↑(compr₂ (TensorProduct.mk R M N)
              (↑(↑(compr₂ (TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)) (homTensorHomMap R M N P Q)) m) n))
          x✝¹)
      x✝
Theorem: BiheytingHom.cancel_left
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.147678
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.147690
inst✝³ : BiheytingAlgebra α
inst✝² : BiheytingAlgebra β
inst✝¹ : BiheytingAlgebra γ
inst✝ : BiheytingAlgebra δ
f f₁ f₂ : BiheytingHom α β
g g₁ g₂ : BiheytingHom β γ
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: FiberBundleCore.localTrivAsLocalEquiv_trans
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: constructor
state_before: ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
⊢ LocalEquiv.trans (LocalEquiv.symm (localTrivAsLocalEquiv Z i)) (localTrivAsLocalEquiv Z j) ≈
    (trivChange Z i j).toLocalEquiv

tactic: ext x
state_before: case left
ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
⊢ (LocalEquiv.trans (LocalEquiv.symm (localTrivAsLocalEquiv Z i)) (localTrivAsLocalEquiv Z j)).source =
    (trivChange Z i j).toLocalEquiv.source

tactic: simp only [mem_localTrivAsLocalEquiv_target, mfld_simps]
state_before: case left.h
ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
x : B × F
⊢ x ∈ (LocalEquiv.trans (LocalEquiv.symm (localTrivAsLocalEquiv Z i)) (localTrivAsLocalEquiv Z j)).source ↔
    x ∈ (trivChange Z i j).toLocalEquiv.source

tactic: rfl
state_before: case left.h
ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
x : B × F
⊢ x.fst ∈ baseSet Z i ∧ ↑(LocalEquiv.symm (localTrivAsLocalEquiv Z i)) x ∈ (localTrivAsLocalEquiv Z j).source ↔
    x.fst ∈ baseSet Z i ∧ x.fst ∈ baseSet Z j

tactic: rintro ⟨x, v⟩ hx
state_before: case right
ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
⊢ EqOn (↑(LocalEquiv.trans (LocalEquiv.symm (localTrivAsLocalEquiv Z i)) (localTrivAsLocalEquiv Z j)))
    (↑(trivChange Z i j).toLocalEquiv)
    (LocalEquiv.trans (LocalEquiv.symm (localTrivAsLocalEquiv Z i)) (localTrivAsLocalEquiv Z j)).source

tactic: simp only [Z.coordChange_comp, hx, mem_inter_iff, and_self_iff, mem_baseSet_at]
state_before: case right.mk
ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.32818
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i✝ i j : ι
x : B
v : F
hx : x ∈ baseSet Z i ∧ x ∈ baseSet Z j
⊢ coordChange Z (indexAt Z x) j x (coordChange Z i (indexAt Z x) x v) = coordChange Z i j x v
Theorem: IsSMulRegular.mul_and_mul_iff
File: Mathlib/Algebra/Regular/SMul.lean

tactic: refine' ⟨_, _⟩
state_before: R : Type u_1
S : Type ?u.7631
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
⊢ IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a) ↔ IsSMulRegular M a ∧ IsSMulRegular M b

tactic: rintro ⟨ab, ba⟩
state_before: case refine'_1
R : Type u_1
S : Type ?u.7631
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
⊢ IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a) → IsSMulRegular M a ∧ IsSMulRegular M b

tactic: refine' ⟨ba.of_mul, ab.of_mul⟩
state_before: case refine'_1.intro
R : Type u_1
S : Type ?u.7631
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
ab : IsSMulRegular M (a * b)
ba : IsSMulRegular M (b * a)
⊢ IsSMulRegular M a ∧ IsSMulRegular M b

tactic: rintro ⟨ha, hb⟩
state_before: case refine'_2
R : Type u_1
S : Type ?u.7631
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
⊢ IsSMulRegular M a ∧ IsSMulRegular M b → IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a)

tactic: exact ⟨ha.mul hb, hb.mul ha⟩
state_before: case refine'_2.intro
R : Type u_1
S : Type ?u.7631
M : Type u_2
a b : R
s : S
inst✝⁵ : SMul R M
inst✝⁴ : SMul R S
inst✝³ : SMul S M
inst✝² : IsScalarTower R S M
inst✝¹ : Mul R
inst✝ : IsScalarTower R R M
ha : IsSMulRegular M a
hb : IsSMulRegular M b
⊢ IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a)
Theorem: Equiv.semiconj_conj
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp
state_before: α₁ : Type u_1
β₁ : Type u_2
e : α₁ ≃ β₁
f✝ : α₁ → α₁ → α₁
f : α₁ → α₁
x : α₁
⊢ ↑e (f x) = ↑(conj e) f (↑e x)
Theorem: mul_div_assoc
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_assoc _ _ _]
state_before: α : Type ?u.18617
β : Type ?u.18620
G : Type u_1
inst✝ : DivInvMonoid G
a✝ b✝ c✝ a b c : G
⊢ a * b / c = a * (b / c)
Theorem: List.erase_eq_eraseP
File: Std/Data/List/Lemmas.lean

tactic: if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l)

tactic: simp [h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : a = b
⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l)

tactic: simp [h, Ne.symm h, erase_eq_eraseP a l]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬a = b
⊢ List.erase (b :: l) a = eraseP (fun b => decide (a = b)) (b :: l)
Theorem: cauchySeq_of_dist_le_of_summable
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

tactic: refine' Metric.cauchySeq_iff'.2 fun ε εpos => _
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
hd : Summable d
⊢ CauchySeq f

tactic: replace hd : CauchySeq fun n : ℕ => ∑ x in range n, d x :=
  let ⟨_, H⟩ := hd
  H.tendsto_sum_nat.cauchySeq
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
hd : Summable d
ε : ℝ
εpos : ε > 0
⊢ ∃ N, ∀ (n : ℕ), n ≥ N → dist (f n) (f N) < ε

tactic: refine' (Metric.cauchySeq_iff'.1 hd ε εpos).imp fun N hN n hn => _
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
ε : ℝ
εpos : ε > 0
hd : CauchySeq fun n => ∑ x in range n, d x
⊢ ∃ N, ∀ (n : ℕ), n ≥ N → dist (f n) (f N) < ε

tactic: have hsum := hN n hn
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
ε : ℝ
εpos : ε > 0
hd : CauchySeq fun n => ∑ x in range n, d x
N : ℕ
hN : ∀ (n : ℕ), n ≥ N → dist (∑ x in range n, d x) (∑ x in range N, d x) < ε
n : ℕ
hn : n ≥ N
⊢ dist (f n) (f N) < ε

tactic: rw [Real.dist_eq, ← sum_Ico_eq_sub _ hn] at hsum
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
ε : ℝ
εpos : ε > 0
hd : CauchySeq fun n => ∑ x in range n, d x
N : ℕ
hN : ∀ (n : ℕ), n ≥ N → dist (∑ x in range n, d x) (∑ x in range N, d x) < ε
n : ℕ
hn : n ≥ N
hsum : dist (∑ x in range n, d x) (∑ x in range N, d x) < ε
⊢ dist (f n) (f N) < ε

tactic: calc
  dist (f n) (f N) = dist (f N) (f n) := dist_comm _ _
  _ ≤ ∑ x in Ico N n, d x := dist_le_Ico_sum_of_dist_le hn fun _ _ => hf _
  _ ≤ |∑ x in Ico N n, d x| := le_abs_self _
  _ < ε := hsum
state_before: α : Type u_1
inst✝ : PseudoMetricSpace α
f : ℕ → α
a : α
d : ℕ → ℝ
hf : ∀ (n : ℕ), dist (f n) (f (Nat.succ n)) ≤ d n
ε : ℝ
εpos : ε > 0
hd : CauchySeq fun n => ∑ x in range n, d x
N : ℕ
hN : ∀ (n : ℕ), n ≥ N → dist (∑ x in range n, d x) (∑ x in range N, d x) < ε
n : ℕ
hn : n ≥ N
hsum : abs (∑ k in Ico N n, d k) < ε
⊢ dist (f n) (f N) < ε
Theorem: IsOpen.smul_left
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← iUnion_smul_set]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
ht : IsOpen t
⊢ IsOpen (s • t)

tactic: exact isOpen_biUnion fun a _ => ht.smul _
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace β
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : ContinuousConstSMul α β
s : Set α
t : Set β
ht : IsOpen t
⊢ IsOpen (⋃ (a : α) (_ : a ∈ s), a • t)