tasksource/leandojo huggingface dataset:
Theorem: PowerBasis.algHom_ext
File: Mathlib/RingTheory/PowerBasis.lean

tactic: ext x
state_before: R : Type u_2
S : Type u_3
T : Type ?u.54281
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type ?u.54584
B : Type ?u.54587
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.55009
inst✝² : Field K
S' : Type u_1
inst✝¹ : Semiring S'
inst✝ : Algebra R S'
pb : PowerBasis R S
f g : S →ₐ[R] S'
h : ↑f pb.gen = ↑g pb.gen
⊢ f = g

tactic: obtain ⟨f, rfl⟩ := pb.exists_eq_aeval' x
state_before: case H
R : Type u_2
S : Type u_3
T : Type ?u.54281
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type ?u.54584
B : Type ?u.54587
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.55009
inst✝² : Field K
S' : Type u_1
inst✝¹ : Semiring S'
inst✝ : Algebra R S'
pb : PowerBasis R S
f g : S →ₐ[R] S'
h : ↑f pb.gen = ↑g pb.gen
x : S
⊢ ↑f x = ↑g x

tactic: rw [← Polynomial.aeval_algHom_apply, ← Polynomial.aeval_algHom_apply, h]
state_before: case H.intro
R : Type u_2
S : Type u_3
T : Type ?u.54281
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type ?u.54584
B : Type ?u.54587
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.55009
inst✝² : Field K
S' : Type u_1
inst✝¹ : Semiring S'
inst✝ : Algebra R S'
pb : PowerBasis R S
f✝ g : S →ₐ[R] S'
h : ↑f✝ pb.gen = ↑g pb.gen
f : R[X]
⊢ ↑f✝ (↑(aeval pb.gen) f) = ↑g (↑(aeval pb.gen) f)
Theorem: disjoint_closedBall_ball_iff
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [disjoint_comm, disjoint_ball_closedBall_iff hε hδ, add_comm, dist_comm]
state_before: 𝕜 : Type ?u.218373
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
⊢ Disjoint (closedBall x δ) (ball y ε) ↔ δ + ε ≤ dist x y
Theorem: Tropical.add_eq_right_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_right_iff]
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
⊢ x + y = y ↔ y ≤ x
Theorem: Set.Ioo.one_minus_lt_one
File: Mathlib/Data/Set/Intervals/Instances.lean

tactic: simpa using x.2.1
state_before: α : Type ?u.66971
inst✝¹ : StrictOrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
x : ↑(Ioo 0 1)
⊢ 1 - ↑x < 1
Theorem: CategoryTheory.hasColimitsOfShape_of_reflective
File: Mathlib/CategoryTheory/Monad/Limits.lean

tactic: let c := (leftAdjoint R).mapCocone (colimit.cocone (F ⋙ R))
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type u
inst✝² : Category J
R : D ⥤ C
inst✝¹ : Reflective R
inst✝ : HasColimitsOfShape J C
F : J ⥤ D
⊢ HasColimit F

tactic: letI : PreservesColimitsOfShape J _ :=
  (Adjunction.ofRightAdjoint R).leftAdjointPreservesColimits.1
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type u
inst✝² : Category J
R : D ⥤ C
inst✝¹ : Reflective R
inst✝ : HasColimitsOfShape J C
F : J ⥤ D
c : Cocone ((F ⋙ R) ⋙ leftAdjoint R) := (leftAdjoint R).mapCocone (colimit.cocone (F ⋙ R))
⊢ HasColimit F

tactic: let t : IsColimit c := isColimitOfPreserves (leftAdjoint R) (colimit.isColimit _)
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type u
inst✝² : Category J
R : D ⥤ C
inst✝¹ : Reflective R
inst✝ : HasColimitsOfShape J C
F : J ⥤ D
c : Cocone ((F ⋙ R) ⋙ leftAdjoint R) := (leftAdjoint R).mapCocone (colimit.cocone (F ⋙ R))
this : PreservesColimitsOfShape J (leftAdjoint R) := PreservesColimitsOfSize.preservesColimitsOfShape
⊢ HasColimit F

tactic: apply HasColimit.mk ⟨_, (IsColimit.precomposeInvEquiv _ _).symm t⟩
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type u
inst✝² : Category J
R : D ⥤ C
inst✝¹ : Reflective R
inst✝ : HasColimitsOfShape J C
F : J ⥤ D
c : Cocone ((F ⋙ R) ⋙ leftAdjoint R) := (leftAdjoint R).mapCocone (colimit.cocone (F ⋙ R))
this : PreservesColimitsOfShape J (leftAdjoint R) := PreservesColimitsOfSize.preservesColimitsOfShape
t : IsColimit c := isColimitOfPreserves (leftAdjoint R) (colimit.isColimit (F ⋙ R))
⊢ HasColimit F

tactic: apply
  (isoWhiskerLeft F (asIso (Adjunction.ofRightAdjoint R).counit) : _) ≪≫ F.rightUnitor
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type u
inst✝² : Category J
R : D ⥤ C
inst✝¹ : Reflective R
inst✝ : HasColimitsOfShape J C
F : J ⥤ D
c : Cocone ((F ⋙ R) ⋙ leftAdjoint R) := (leftAdjoint R).mapCocone (colimit.cocone (F ⋙ R))
this : PreservesColimitsOfShape J (leftAdjoint R) := PreservesColimitsOfSize.preservesColimitsOfShape
t : IsColimit c := isColimitOfPreserves (leftAdjoint R) (colimit.isColimit (F ⋙ R))
⊢ (F ⋙ R) ⋙ leftAdjoint R ≅ F
Theorem: Vector.reverse_get_zero
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [← get_zero, last_def, get_eq_get, get_eq_get]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ head (reverse v) = last v

tactic: simp_rw [toList_reverse]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ List.get (toList (reverse v)) (↑(Fin.cast (_ : Nat.succ n = List.length (toList (reverse v)))) 0) =
    List.get (toList v) (↑(Fin.cast (_ : n + 1 = List.length (toList v))) (Fin.last n))

tactic: rw [← Option.some_inj, ← List.get?_eq_get, ← List.get?_eq_get, List.get?_reverse]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ List.get (List.reverse (toList v)) (↑(Fin.cast (_ : Nat.succ n = List.length (toList (reverse v)))) 0) =
    List.get (toList v) (↑(Fin.cast (_ : n + 1 = List.length (toList v))) (Fin.last n))

tactic: congr
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ List.get? (toList v)
      (List.length (toList v) - 1 - ↑(↑(Fin.cast (_ : Nat.succ n = List.length (toList (reverse v)))) 0)) =
    List.get? (toList v) ↑(↑(Fin.cast (_ : n + 1 = List.length (toList v))) (Fin.last n))

tactic: simp
state_before: case e_a
n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ List.length (toList v) - 1 - ↑(↑(Fin.cast (_ : Nat.succ n = List.length (toList (reverse v)))) 0) =
    ↑(↑(Fin.cast (_ : n + 1 = List.length (toList v))) (Fin.last n))

tactic: simp
state_before: case h
n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ ↑(↑(Fin.cast (_ : Nat.succ n = List.length (toList (reverse v)))) 0) < List.length (toList v)
Theorem: expNegInvGlue.contDiff_polynomial_eval_inv_mul
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: apply contDiff_all_iff_nat.2 (fun m => ?_) n
state_before: n : ℕ∞
p : ℝ[X]
⊢ ContDiff ℝ n fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

tactic: induction m generalizing p with
| zero => exact contDiff_zero.2 <| continuous_polynomial_eval_inv_mul _
| succ m ihm =>
  refine contDiff_succ_iff_deriv.2 ⟨differentiable_polynomial_eval_inv_mul _, ?_⟩
  convert ihm (X ^ 2 * (p - derivative (R := ℝ) p)) using 2
  exact (hasDerivAt_polynomial_eval_inv_mul p _).deriv
state_before: n : ℕ∞
p : ℝ[X]
m : ℕ
⊢ ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

tactic: exact contDiff_zero.2 <| continuous_polynomial_eval_inv_mul _
state_before: case zero
n : ℕ∞
p : ℝ[X]
⊢ ContDiff ℝ ↑Nat.zero fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

tactic: refine contDiff_succ_iff_deriv.2 ⟨differentiable_polynomial_eval_inv_mul _, ?_⟩
state_before: case succ
n : ℕ∞
m : ℕ
ihm : ∀ (p : ℝ[X]), ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
p : ℝ[X]
⊢ ContDiff ℝ ↑(Nat.succ m) fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x

tactic: convert ihm (X ^ 2 * (p - derivative (R := ℝ) p)) using 2
state_before: case succ
n : ℕ∞
m : ℕ
ihm : ∀ (p : ℝ[X]), ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
p : ℝ[X]
⊢ ContDiff ℝ (↑m) (deriv fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x)

tactic: exact (hasDerivAt_polynomial_eval_inv_mul p _).deriv
state_before: case h.e'_10.h
n : ℕ∞
m : ℕ
ihm : ∀ (p : ℝ[X]), ContDiff ℝ ↑m fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
p : ℝ[X]
x✝ : ℝ
⊢ deriv (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) x✝ =
    Polynomial.eval x✝⁻¹ (X ^ 2 * (p - ↑derivative p)) * expNegInvGlue x✝
Theorem: Algebra.FinitePresentation.iff
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: constructor
state_before: R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
⊢ FinitePresentation R A ↔ ∃ n I x, Ideal.FG I

tactic: rintro ⟨n, f, hf⟩
state_before: case mp
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
⊢ FinitePresentation R A → ∃ n I x, Ideal.FG I

tactic: exact ⟨n, RingHom.ker f.toRingHom, Ideal.quotientKerAlgEquivOfSurjective hf.1, hf.2⟩
state_before: case mp.intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ↑f ∧ Ideal.FG (RingHom.ker ↑f)
⊢ ∃ n I x, Ideal.FG I

tactic: rintro ⟨n, I, e, hfg⟩
state_before: case mpr
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
⊢ (∃ n I x, Ideal.FG I) → FinitePresentation R A

tactic: exact equiv ((FinitePresentation.mvPolynomial R _).quotient hfg) e
state_before: case mpr.intro.intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
n : ℕ
I : Ideal (MvPolynomial (Fin n) R)
e : (MvPolynomial (Fin n) R ⧸ I) ≃ₐ[R] A
hfg : Ideal.FG I
⊢ FinitePresentation R A
Theorem: Equiv.Perm.mem_support_swap_mul_imp_mem_support_ne
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [mem_support, swap_apply_def, mul_apply, f.injective.eq_iff] at *
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hy : y ∈ support (swap x (↑f x) * f)
⊢ y ∈ support f ∧ y ≠ x

tactic: by_cases h : f y = x
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hy : (if ↑f y = x then ↑f x else if y = x then x else ↑f y) ≠ y
⊢ ↑f y ≠ y ∧ y ≠ x

tactic: constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hy : (if ↑f y = x then ↑f x else if y = x then x else ↑f y) ≠ y
h : ↑f y = x
⊢ ↑f y ≠ y ∧ y ≠ x

tactic: split_ifs at hy with hf heq <;>
simp_all only [not_true]
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hy : (if ↑f y = x then ↑f x else if y = x then x else ↑f y) ≠ y
h : ¬↑f y = x
⊢ ↑f y ≠ y ∧ y ≠ x

tactic: exact ⟨h, hy⟩
state_before: case neg.inr.inl
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
h : ¬↑f x = x
heq : y = x
hy : x ≠ x
⊢ ↑f x ≠ x ∧ x ≠ x

case neg.inr.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hf : ¬↑f y = x
heq : ¬y = x
hy : ↑f y ≠ y
⊢ ↑f y ≠ y ∧ y ≠ x

tactic: refine' ⟨hy, heq⟩
state_before: case neg.inr.inr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hf : ¬↑f y = x
heq : ¬y = x
hy : ↑f y ≠ y
⊢ ↑f y ≠ y ∧ y ≠ x
Theorem: CauchySeq.tendsto_uniformity
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simpa only [Tendsto, prod_map_map_eq', prod_atTop_atTop_eq] using h.right
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : SemilatticeSup β
u : β → α
h : CauchySeq u
⊢ Tendsto (Prod.map u u) atTop (𝓤 α)
Theorem: PowerBasis.constr_pow_mul
File: Mathlib/RingTheory/PowerBasis.lean

tactic: obtain ⟨f, rfl⟩ := pb.exists_eq_aeval' x
state_before: R : Type ?u.455322
S : Type u_2
T : Type ?u.455328
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_1
B : Type ?u.455634
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type ?u.456056
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_3
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : ↑(aeval y) (minpoly A pb.gen) = 0
x x' : S
⊢ ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (x * x') =
    ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) x * ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) x'

tactic: obtain ⟨g, rfl⟩ := pb.exists_eq_aeval' x'
state_before: case intro
R : Type ?u.455322
S : Type u_2
T : Type ?u.455328
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_1
B : Type ?u.455634
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type ?u.456056
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_3
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : ↑(aeval y) (minpoly A pb.gen) = 0
x' : S
f : A[X]
⊢ ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (↑(aeval pb.gen) f * x') =
    ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (↑(aeval pb.gen) f) * ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) x'

tactic: simp only [← aeval_mul, pb.constr_pow_aeval hy]
state_before: case intro.intro
R : Type ?u.455322
S : Type u_2
T : Type ?u.455328
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_1
B : Type ?u.455634
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type ?u.456056
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_3
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : ↑(aeval y) (minpoly A pb.gen) = 0
f g : A[X]
⊢ ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (↑(aeval pb.gen) f * ↑(aeval pb.gen) g) =
    ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (↑(aeval pb.gen) f) *
      ↑(↑(Basis.constr pb.basis A) fun i => y ^ ↑i) (↑(aeval pb.gen) g)
Theorem: eq_div_iff_mul_eq'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, eq_mul_inv_iff_mul_eq]
state_before: α : Type ?u.62263
β : Type ?u.62266
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a = b / c ↔ a * c = b
Theorem: Set.pairwise_disjoint_Ico_zpow
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [one_mul] using pairwise_disjoint_Ico_mul_zpow 1 b
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
⊢ Pairwise (Disjoint on fun n => Ico (b ^ n) (b ^ (n + 1)))
Theorem: MeasureTheory.Memℒp.toLp_eq_toLp_iff
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [toLp]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.350511
G : Type ?u.350514
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : Memℒp f p
hg : Memℒp g p
⊢ toLp f hf = toLp g hg ↔ f =ᵐ[μ] g
Theorem: Trivialization.frontier_preimage
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [← (e.isImage_preimage_prod s).frontier.preimage_eq, frontier_prod_univ_eq,
  (e.isImage_preimage_prod _).preimage_eq, e.source_eq, preimage_inter]
state_before: ι : Type ?u.62554
B : Type u_1
F : Type u_2
E : B → Type ?u.62565
Z : Type u_3
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b : B
y : E b
B' : Type ?u.62653
inst✝ : TopologicalSpace B'
e : Trivialization F proj
s : Set B
⊢ e.source ∩ frontier (proj ⁻¹' s) = proj ⁻¹' (e.baseSet ∩ frontier s)
Theorem: ModuleCat.ihom_ev_app
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean

tactic: apply TensorProduct.ext'
state_before: R : Type u
inst✝ : CommRing R
M N : ModuleCat R
⊢ (ihom.ev M).app N = ↑(TensorProduct.uncurry R (↑M) (↑M →ₗ[R] ↑N) ↑N) (LinearMap.flip LinearMap.id)

tactic: apply ModuleCat.monoidalClosed_uncurry
state_before: case H
R : Type u
inst✝ : CommRing R
M N : ModuleCat R
⊢ ∀ (x : ↑M) (y : ↑((ihom M).obj N)),
    ↑((ihom.ev M).app N) (x ⊗ₜ[R] y) =
      ↑(↑(TensorProduct.uncurry R (↑M) (↑M →ₗ[R] ↑N) ↑N) (LinearMap.flip LinearMap.id)) (x ⊗ₜ[R] y)
Theorem: Subgroup.mem_sSup_of_directedOn
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: haveI : Nonempty K := Kne.to_subtype
state_before: G : Type u_1
G' : Type ?u.229139
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.229148
inst✝ : AddGroup A
H K✝ : Subgroup G
k : Set G
K : Set (Subgroup G)
Kne : Set.Nonempty K
hK : DirectedOn (fun x x_1 => x ≤ x_1) K
x : G
⊢ x ∈ sSup K ↔ ∃ s, s ∈ K ∧ x ∈ s

tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hK.directed_val, SetCoe.exists, Subtype.coe_mk,
  exists_prop]
state_before: G : Type u_1
G' : Type ?u.229139
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.229148
inst✝ : AddGroup A
H K✝ : Subgroup G
k : Set G
K : Set (Subgroup G)
Kne : Set.Nonempty K
hK : DirectedOn (fun x x_1 => x ≤ x_1) K
x : G
this : Nonempty ↑K
⊢ x ∈ sSup K ↔ ∃ s, s ∈ K ∧ x ∈ s
Theorem: mul_right_inv
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← mul_left_inv a⁻¹, inv_eq_of_mul (mul_left_inv a)]
state_before: G : Type u_1
inst✝ : Group G
a✝ b c a : G
⊢ a * a⁻¹ = 1
Theorem: Localization.algEquiv_symm_mk
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [mk_eq_mk', algEquiv_symm_mk']
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.2944703
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
⊢ ↑(AlgEquiv.symm (algEquiv M S)) (mk' S x y) = mk x y
Theorem: Polynomial.aeval_primPart_eq_zero
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [eq_C_content_mul_primPart p, map_mul, aeval_C] at hp
state_before: R : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : NormalizedGCDMonoid R
S : Type u_1
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : NoZeroSMulDivisors R S
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑(aeval s) p = 0
⊢ ↑(aeval s) (primPart p) = 0

tactic: have hcont : p.content ≠ 0 := fun h => hpzero (content_eq_zero_iff.1 h)
state_before: R : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : NormalizedGCDMonoid R
S : Type u_1
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : NoZeroSMulDivisors R S
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑(algebraMap R S) (content p) * ↑(aeval s) (primPart p) = 0
⊢ ↑(aeval s) (primPart p) = 0

tactic: replace hcont := Function.Injective.ne (NoZeroSMulDivisors.algebraMap_injective R S) hcont
state_before: R : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : NormalizedGCDMonoid R
S : Type u_1
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : NoZeroSMulDivisors R S
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑(algebraMap R S) (content p) * ↑(aeval s) (primPart p) = 0
hcont : content p ≠ 0
⊢ ↑(aeval s) (primPart p) = 0

tactic: rw [map_zero] at hcont
state_before: R : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : NormalizedGCDMonoid R
S : Type u_1
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : NoZeroSMulDivisors R S
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑(algebraMap R S) (content p) * ↑(aeval s) (primPart p) = 0
hcont : ↑(algebraMap R S) (content p) ≠ ↑(algebraMap R S) 0
⊢ ↑(aeval s) (primPart p) = 0

tactic: exact eq_zero_of_ne_zero_of_mul_left_eq_zero hcont hp
state_before: R : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : NormalizedGCDMonoid R
S : Type u_1
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : Algebra R S
inst✝ : NoZeroSMulDivisors R S
p : R[X]
s : S
hpzero : p ≠ 0
hp : ↑(algebraMap R S) (content p) * ↑(aeval s) (primPart p) = 0
hcont : ↑(algebraMap R S) (content p) ≠ 0
⊢ ↑(aeval s) (primPart p) = 0
Theorem: Int.mem_range_iff
File: Mathlib/Data/Int/Range.lean

tactic: simp only [range, List.mem_map, List.mem_range, lt_toNat, lt_sub_iff_add_lt, add_comm]
state_before: m n r : ℤ
⊢ r ∈ range m n ↔ m ≤ r ∧ r < n

tactic: exact ⟨fun ⟨a, ha⟩ => ha.2 ▸ ⟨le_add_of_nonneg_right (Int.coe_nat_nonneg _), ha.1⟩,
  fun h => ⟨toNat (r - m), by simp [toNat_of_nonneg (sub_nonneg.2 h.1), h.2] ⟩⟩
state_before: m n r : ℤ
⊢ (∃ a, m + ↑a < n ∧ m + ↑a = r) ↔ m ≤ r ∧ r < n

tactic: simp [toNat_of_nonneg (sub_nonneg.2 h.1), h.2]
state_before: m n r : ℤ
h : m ≤ r ∧ r < n
⊢ m + ↑(toNat (r - m)) < n ∧ m + ↑(toNat (r - m)) = r
Theorem: Localization.map_isUnit_of_le
File: Mathlib/RingTheory/Localization/AsSubring.lean

tactic: apply IsLocalization.map_units K (⟨s.1, hS s.2⟩ : A⁰)
state_before: A : Type u_1
K : Type u_2
inst✝³ : CommRing A
S : Submonoid A
hS✝ : S ≤ A⁰
inst✝² : CommRing K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
hS : S ≤ A⁰
s : { x // x ∈ S }
⊢ IsUnit (↑(algebraMap A K) ↑s)
Theorem: Nat.Squarefree.factorization_le_one
File: Mathlib/Data/Nat/Squarefree.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn')
state_before: n p : ℕ
hn : Squarefree n
⊢ ↑(factorization n) p ≤ 1

tactic: rw [multiplicity.squarefree_iff_multiplicity_le_one] at hn
state_before: case inr
n p : ℕ
hn : Squarefree n
hn' : n ≠ 0
⊢ ↑(factorization n) p ≤ 1

tactic: by_cases hp : p.Prime
state_before: case inr
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
⊢ ↑(factorization n) p ≤ 1

tactic: simp
state_before: case inl
p : ℕ
hn : Squarefree 0
⊢ ↑(factorization 0) p ≤ 1

tactic: have := hn p
state_before: case pos
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
hp : Prime p
⊢ ↑(factorization n) p ≤ 1

tactic: simp only [multiplicity_eq_factorization hp hn', Nat.isUnit_iff, hp.ne_one, or_false_iff]
  at this
state_before: case pos
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
hp : Prime p
this : multiplicity p n ≤ 1 ∨ IsUnit p
⊢ ↑(factorization n) p ≤ 1

tactic: exact_mod_cast this
state_before: case pos
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
hp : Prime p
this : ↑(↑(factorization n) p) ≤ 1
⊢ ↑(factorization n) p ≤ 1

tactic: rw [factorization_eq_zero_of_non_prime _ hp]
state_before: case neg
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
hp : ¬Prime p
⊢ ↑(factorization n) p ≤ 1

tactic: exact zero_le_one
state_before: case neg
n p : ℕ
hn✝ : Squarefree n
hn : ∀ (x : ℕ), multiplicity x n ≤ 1 ∨ IsUnit x
hn' : n ≠ 0
hp : ¬Prime p
⊢ 0 ≤ 1
Theorem: Subsemigroup.comap_id
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: simp
state_before: M : Type ?u.7514
N : Type ?u.7517
P : Type u_1
σ : Type ?u.7523
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S✝ : Subsemigroup M
S : Subsemigroup P
⊢ ∀ (x : P), x ∈ comap (MulHom.id P) S ↔ x ∈ S
Theorem: Int.floor_nonpos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← @cast_le α, Int.cast_zero]
state_before: F : Type ?u.124074
α : Type u_1
β : Type ?u.124080
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : a ≤ 0
⊢ ⌊a⌋ ≤ 0

tactic: exact (floor_le a).trans ha
state_before: F : Type ?u.124074
α : Type u_1
β : Type ?u.124080
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : a ≤ 0
⊢ ↑⌊a⌋ ≤ 0
Theorem: locallyFinite_option
File: Mathlib/Topology/LocallyFinite.lean

tactic: rw [← (Equiv.optionEquivSumPUnit.{_, 0} ι).symm.locallyFinite_comp_iff, locallyFinite_sum]
state_before: ι : Type u_1
ι' : Type ?u.14374
α : Type ?u.14377
X : Type u_2
Y : Type ?u.14383
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f✝ g : ι → Set X
f : Option ι → Set X
⊢ LocallyFinite f ↔ LocallyFinite (f ∘ some)

tactic: simp only [locallyFinite_of_finite, and_true]
state_before: ι : Type u_1
ι' : Type ?u.14374
α : Type ?u.14377
X : Type u_2
Y : Type ?u.14383
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f✝ g : ι → Set X
f : Option ι → Set X
⊢ LocallyFinite ((f ∘ ↑(Equiv.optionEquivSumPUnit ι).symm) ∘ Sum.inl) ∧
      LocallyFinite ((f ∘ ↑(Equiv.optionEquivSumPUnit ι).symm) ∘ Sum.inr) ↔
    LocallyFinite (f ∘ some)

tactic: rfl
state_before: ι : Type u_1
ι' : Type ?u.14374
α : Type ?u.14377
X : Type u_2
Y : Type ?u.14383
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f✝ g : ι → Set X
f : Option ι → Set X
⊢ LocallyFinite ((f ∘ ↑(Equiv.optionEquivSumPUnit ι).symm) ∘ Sum.inl) ↔ LocallyFinite (f ∘ some)