tasksource/leandojo huggingface dataset:
Theorem: ProbabilityTheory.kernel.restrict_univ
File: Mathlib/Probability/Kernel/Basic.lean

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1444502
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
s t : Set β
⊢ kernel.restrict κ (_ : MeasurableSet Set.univ) = κ

tactic: rw [kernel.restrict_apply, Measure.restrict_univ]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type ?u.1444502
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
s t : Set β
a : α
⊢ ↑(kernel.restrict κ (_ : MeasurableSet Set.univ)) a = ↑κ a
Theorem: SimplexCategory.δ_comp_δ_self'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: subst H
state_before: n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : j = ↑Fin.castSucc i
⊢ δ i ≫ δ j = δ i ≫ δ (Fin.succ i)

tactic: rw [δ_comp_δ_self]
state_before: n : ℕ
i : Fin (n + 2)
⊢ δ i ≫ δ (↑Fin.castSucc i) = δ i ≫ δ (Fin.succ i)
Theorem: Set.mem_ite_empty_left
File: Mathlib/Data/Set/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : Set α
x : α
⊢ (∃ h, x ∈ t) ↔ ¬p ∧ x ∈ t
Theorem: CategoryTheory.Limits.WidePushout.hom_eq_desc
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: rw [← Category.assoc]
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type ?u.254030
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
j : J
⊢ arrows j ≫ (fun j => ι arrows j ≫ g) j = head arrows ≫ g

tactic: simp
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type ?u.254030
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
j : J
⊢ (arrows j ≫ ι arrows j) ≫ g = head arrows ≫ g

tactic: apply eq_desc_of_comp_eq
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) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ g =
    desc (head arrows ≫ g) (fun j => ι arrows j ≫ g)
      (_ : ∀ (j : J), arrows j ≫ (fun j => ι arrows j ≫ g) j = head arrows ≫ g)

tactic: aesop_cat
state_before: case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ ∀ (j : J), ι arrows j ≫ g = ι arrows j ≫ g

case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ head arrows ≫ g = head arrows ≫ g

tactic: rfl
state_before: case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ head arrows ≫ g = head arrows ≫ g
Theorem: Monoid.exponent_ne_zero_of_finite
File: Mathlib/GroupTheory/Exponent.lean

tactic: cases nonempty_fintype G
state_before: G : Type u
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
⊢ exponent G ≠ 0

tactic: simpa [← lcm_order_eq_exponent, Finset.lcm_eq_zero_iff] using fun x => (orderOf_pos x).ne'
state_before: case intro
G : Type u
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
val✝ : Fintype G
⊢ exponent G ≠ 0
Theorem: LatticeOrderedCommGroup.pos_of_one_le
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [m_pos_part_def]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
h : 1 ≤ a
⊢ a⁺ = a

tactic: exact sup_of_le_left h
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
h : 1 ≤ a
⊢ a ⊔ 1 = a
Theorem: aestronglyMeasurable_union_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp only [union_eq_iUnion, aestronglyMeasurable_iUnion_iff, Bool.forall_bool, cond, and_comm]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.401923
ι : Type ?u.401926
inst✝³ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
s t : Set α
⊢ AEStronglyMeasurable f (Measure.restrict μ (s ∪ t)) ↔
    AEStronglyMeasurable f (Measure.restrict μ s) ∧ AEStronglyMeasurable f (Measure.restrict μ t)
Theorem: Real.map_volume_mul_left
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: conv_rhs =>
  rw [← Real.smul_map_volume_mul_left h, smul_smul, ← ENNReal.ofReal_mul (abs_nonneg _), ←
    abs_mul, inv_mul_cancel h, abs_one, ENNReal.ofReal_one, one_smul]
state_before: ι : Type ?u.2204078
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
⊢ Measure.map (fun x => a * x) volume = ofReal (abs a⁻¹) • volume
Theorem: Subalgebra.fg_of_fg_map
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [← Algebra.adjoin_image, Finset.coe_preimage, Set.image_preimage_eq_of_subset, hs]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ↑f
hs✝ : FG (map f S)
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ map f
      (Algebra.adjoin R
        ↑(Finset.preimage s ↑f
            (_ : ∀ (x : A), x ∈ ↑f ⁻¹' ↑s → ∀ (x_2 : A), x_2 ∈ ↑f ⁻¹' ↑s → ↑f x = ↑f x_2 → x = x_2))) =
    map f S

tactic: rw [← AlgHom.coe_range, ← Algebra.adjoin_le_iff, hs, ← Algebra.map_top]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ↑f
hs✝ : FG (map f S)
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ ↑s ⊆ Set.range ↑f

tactic: exact map_mono le_top
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hf : Function.Injective ↑f
hs✝ : FG (map f S)
s : Finset B
hs : Algebra.adjoin R ↑s = map f S
⊢ map f S ≤ map f ⊤
Theorem: CategoryTheory.Limits.Cotrident.ofCocone_ι
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: cases j <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
t : Cocone F
j : WalkingParallelFamily J
⊢ (parallelFamily fun j => F.map (line j)).obj j = F.obj j
Theorem: SimpleGraph.Subgraph.subgraphOfAdj_eq_induce
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext
state_before: ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
⊢ subgraphOfAdj G hvw = induce ⊤ {v, w}

tactic: simp
state_before: case verts.h
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝ : V
⊢ x✝ ∈ (subgraphOfAdj G hvw).verts ↔ x✝ ∈ (induce ⊤ {v, w}).verts

tactic: constructor
state_before: case Adj.h.h.a
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝ ↔ Adj (induce ⊤ {v, w}) x✝¹ x✝

tactic: intro h
state_before: case Adj.h.h.a.mp
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝ → Adj (induce ⊤ {v, w}) x✝¹ x✝

tactic: simp only [subgraphOfAdj_Adj, Quotient.eq, Sym2.rel_iff] at h
state_before: case Adj.h.h.a.mp
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : Adj (subgraphOfAdj G hvw) x✝¹ x✝
⊢ Adj (induce ⊤ {v, w}) x✝¹ x✝

tactic: obtain ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ := h <;> simp [hvw, hvw.symm]
state_before: case Adj.h.h.a.mp
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : v = x✝¹ ∧ w = x✝ ∨ v = x✝ ∧ w = x✝¹
⊢ Adj (induce ⊤ {v, w}) x✝¹ x✝

tactic: intro h
state_before: case Adj.h.h.a.mpr
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
⊢ Adj (induce ⊤ {v, w}) x✝¹ x✝ → Adj (subgraphOfAdj G hvw) x✝¹ x✝

tactic: simp only [induce_Adj, Set.mem_insert_iff, Set.mem_singleton_iff, top_adj] at h
state_before: case Adj.h.h.a.mpr
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : Adj (induce ⊤ {v, w}) x✝¹ x✝
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝

tactic: obtain ⟨rfl | rfl, rfl | rfl, ha⟩ := h <;> first |exact (ha.ne rfl).elim|simp
state_before: case Adj.h.h.a.mpr
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v w : V
hvw : SimpleGraph.Adj G v w
x✝¹ x✝ : V
h : (x✝¹ = v ∨ x✝¹ = w) ∧ (x✝ = v ∨ x✝ = w) ∧ SimpleGraph.Adj G x✝¹ x✝
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝

tactic: exact (ha.ne rfl).elim
state_before: case Adj.h.h.a.mpr.intro.inr.intro.inr
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
v x✝ : V
hvw : SimpleGraph.Adj G v x✝
ha : SimpleGraph.Adj G x✝ x✝
⊢ Adj (subgraphOfAdj G hvw) x✝ x✝

tactic: simp
state_before: case Adj.h.h.a.mpr.intro.inr.intro.inl
ι : Sort ?u.263704
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
x✝¹ x✝ : V
ha : SimpleGraph.Adj G x✝¹ x✝
hvw : SimpleGraph.Adj G x✝ x✝¹
⊢ Adj (subgraphOfAdj G hvw) x✝¹ x✝
Theorem: IsSemisimpleModule.sSup_simples_eq_top
File: Mathlib/RingTheory/SimpleModule.lean

tactic: simp_rw [isSimpleModule_iff_isAtom]
state_before: R : Type u_2
inst✝⁵ : Ring R
M : Type u_1
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type ?u.40765
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSemisimpleModule R M
⊢ sSup {m | IsSimpleModule R { x // x ∈ m }} = ⊤

tactic: exact sSup_atoms_eq_top
state_before: R : Type u_2
inst✝⁵ : Ring R
M : Type u_1
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type ?u.40765
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSemisimpleModule R M
⊢ sSup {m | IsAtom m} = ⊤
Theorem: Algebra.FiniteType.of_surjective
File: Mathlib/RingTheory/FiniteType.lean

tactic: convert hRA.1.map f
state_before: R : Type u_1
A : Type u
B : Type u_2
M : Type ?u.22919
N : Type ?u.22922
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
hRA : FiniteType R A
f : A →ₐ[R] B
hf : Surjective ↑f
⊢ Subalgebra.FG ⊤

tactic: simpa only [map_top f, @eq_comm _ ⊤, eq_top_iff, AlgHom.mem_range] using hf
state_before: case h.e'_6
R : Type u_1
A : Type u
B : Type u_2
M : Type ?u.22919
N : Type ?u.22922
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
hRA : FiniteType R A
f : A →ₐ[R] B
hf : Surjective ↑f
⊢ ⊤ = Subalgebra.map f ⊤
Theorem: Int.pos_of_neg_neg
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.neg_zero]
state_before: a : Int
h : -a < 0
⊢ -a < -0
Theorem: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_fac
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: dsimp [coconeOfHom, colimitCocone, Cocone.extend]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
⊢ coconeOfHom h f = Cocone.extend (colimitCocone h) f

tactic: congr with j
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
⊢ { pt := Y, ι := h.hom.app Y { down := f } } = { pt := Y, ι := h.hom.app X { down := 𝟙 X } ≫ (const J).map f }

tactic: have t := congrFun (h.hom.naturality f) ⟨𝟙 X⟩
state_before: case e_ι.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
⊢ (h.hom.app Y { down := f }).app j = (h.hom.app X { down := 𝟙 X } ≫ (const J).map f).app j

tactic: dsimp at t
state_before: case e_ι.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t :
  ((coyoneda.obj X.op ⋙ uliftFunctor).map f ≫ h.hom.app Y) { down := 𝟙 X } =
    (h.hom.app X ≫ (Functor.cocones F).map f) { down := 𝟙 X }
⊢ (h.hom.app Y { down := f }).app j = (h.hom.app X { down := 𝟙 X } ≫ (const J).map f).app j

tactic: simp only [id_comp] at t
state_before: case e_ι.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : h.hom.app Y { down := 𝟙 X ≫ f } = (Functor.cocones F).map f (h.hom.app X { down := 𝟙 X })
⊢ (h.hom.app Y { down := f }).app j = (h.hom.app X { down := 𝟙 X } ≫ (const J).map f).app j

tactic: rw [congrFun (congrArg NatTrans.app t) j]
state_before: case e_ι.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : h.hom.app Y { down := f } = (Functor.cocones F).map f (h.hom.app X { down := 𝟙 X })
⊢ (h.hom.app Y { down := f }).app j = (h.hom.app X { down := 𝟙 X } ≫ (const J).map f).app j

tactic: rfl
state_before: case e_ι.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : h.hom.app Y { down := f } = (Functor.cocones F).map f (h.hom.app X { down := 𝟙 X })
⊢ ((Functor.cocones F).map f (h.hom.app X { down := 𝟙 X })).app j =
    (h.hom.app X { down := 𝟙 X } ≫ (const J).map f).app j
Theorem: IsMulHom.mul
File: Mathlib/Deprecated/Group.lean

tactic: simp only [hf.map_mul, hg.map_mul, mul_comm, mul_assoc, mul_left_comm]
state_before: α✝ : Type u
β✝ : Type v
inst✝⁴ : Mul α✝
inst✝³ : Mul β✝
γ : Type ?u.931
inst✝² : Mul γ
α : Type u_1
β : Type u_2
inst✝¹ : Semigroup α
inst✝ : CommSemigroup β
f g : α → β
hf : IsMulHom f
hg : IsMulHom g
a b : α
⊢ f (a * b) * g (a * b) = f a * g a * (f b * g b)
Theorem: Subgroup.isOpen_of_mem_nhds
File: Mathlib/Topology/Algebra/OpenSubgroup.lean

tactic: refine' isOpen_iff_mem_nhds.2 fun x hx => _
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
⊢ IsOpen ↑H

tactic: have hg' : g ∈ H := SetLike.mem_coe.1 (mem_of_mem_nhds hg)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
⊢ ↑H ∈ 𝓝 x

tactic: have : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g) :=
  (continuous_id.mul continuous_const).tendsto' _ _ (mul_inv_cancel_left _ _)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
⊢ ↑H ∈ 𝓝 x

tactic: simpa only [SetLike.mem_coe, Filter.mem_map',
  H.mul_mem_cancel_right (H.mul_mem (H.inv_mem hx) hg')] using this hg
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
this : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g)
⊢ ↑H ∈ 𝓝 x
Theorem: Int.testBit_land
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_and, testBit_bitwise]
state_before: m n : ℤ
k : ℕ
⊢ testBit (land m n) k = (testBit m k && testBit n k)
Theorem: ContinuousLinearMap.map_zero₂
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [f.map_zero, zero_apply]
state_before: 𝕜 : Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type ?u.150367
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type u_5
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type ?u.150552
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
R : Type u_1
𝕜₂ : Type u_7
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NontriviallyNormedField 𝕜₂
M : Type u_3
inst✝⁷ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_4
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜₂ G'
inst✝⁴ : NormedSpace 𝕜' G'
inst✝³ : SMulCommClass 𝕜₂ 𝕜' G'
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ρ₁₂ : R →+* 𝕜'
f : M →SL[ρ₁₂] F →SL[σ₁₂] G'
y : F
⊢ ↑(↑f 0) y = 0
Theorem: FreeGroup.Red.cons_nil_iff_singleton
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: have h₁ : Red ((x, not b) :: (x, b) :: L) [(x, not b)] := cons_cons h
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
⊢ Red L [(x, !b)]

tactic: have h₂ : Red ((x, not b) :: (x, b) :: L) L := ReflTransGen.single Step.cons_not_rev
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
⊢ Red L [(x, !b)]

tactic: let ⟨L', h₁, h₂⟩ := church_rosser h₁ h₂
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂ : Red ((x, !b) :: (x, b) :: L) L
⊢ Red L [(x, !b)]

tactic: rw [singleton_iff] at h₁
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : Red [(x, !b)] L'
h₂ : Red L L'
⊢ Red L [(x, !b)]

tactic: subst L'
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁✝ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
L' : List (α × Bool)
h₁ : L' = [(x, !b)]
h₂ : Red L L'
⊢ Red L [(x, !b)]

tactic: assumption
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
x : α
b : Bool
h : Red ((x, b) :: L) []
h₁ : Red ((x, !b) :: (x, b) :: L) [(x, !b)]
h₂✝ : Red ((x, !b) :: (x, b) :: L) L
h₂ : Red L [(x, !b)]
⊢ Red L [(x, !b)]
Theorem: Matrix.StdBasisMatrix.apply_of_col_ne
File: Mathlib/Data/Matrix/Basis.lean

tactic: simp [hj]
state_before: l : Type ?u.23553
m : Type u_3
n : Type u_1
R : Type ?u.23562
α : Type u_2
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i✝ : m
j✝ : n
c : α
i'✝ : m
j'✝ : n
i i' : m
j j' : n
hj : j ≠ j'
a : α
⊢ stdBasisMatrix i j a i' j' = 0
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.homOfLe_ι
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G✝ G'✝ G G' : Subpresheaf F
h : G ≤ G'
⊢ homOfLe h ≫ ι G' = ι G

tactic: rfl
state_before: case w.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G✝ G'✝ G G' : Subpresheaf F
h : G ≤ G'
x✝ : Cᵒᵖ
a✝ : (toPresheaf G).obj x✝
⊢ (homOfLe h ≫ ι G').app x✝ a✝ = (ι G).app x✝ a✝
Theorem: Set.Infinite.exists_supset_ncard_eq
File: Mathlib/Data/Set/Ncard.lean

tactic: obtain ⟨s₁, hs₁, hs₁fin, hs₁card⟩ := (ht.diff hs).exists_subset_ncard_eq (k - s.ncard)
state_before: α : Type u_1
β : Type ?u.135186
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : Set.Infinite t
hst : s ⊆ t
hs : Set.Finite s
k : ℕ
hsk : Set.ncard s ≤ k
⊢ ∃ s', s ⊆ s' ∧ s' ⊆ t ∧ Set.ncard s' = k

tactic: refine' ⟨s ∪ s₁, subset_union_left _ _, union_subset hst (hs₁.trans (diff_subset _ _)), _⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.135186
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : Set.Infinite t
hst : s ⊆ t
hs : Set.Finite s
k : ℕ
hsk : Set.ncard s ≤ k
s₁ : Set α
hs₁ : s₁ ⊆ t \ s
hs₁fin : Set.Finite s₁
hs₁card : Set.ncard s₁ = k - Set.ncard s
⊢ ∃ s', s ⊆ s' ∧ s' ⊆ t ∧ Set.ncard s' = k

tactic: rwa [ncard_union_eq (disjoint_of_subset_right hs₁ disjoint_sdiff_right) hs hs₁fin, hs₁card,
  add_tsub_cancel_of_le]
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.135186
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : Set.Infinite t
hst : s ⊆ t
hs : Set.Finite s
k : ℕ
hsk : Set.ncard s ≤ k
s₁ : Set α
hs₁ : s₁ ⊆ t \ s
hs₁fin : Set.Finite s₁
hs₁card : Set.ncard s₁ = k - Set.ncard s
⊢ Set.ncard (s ∪ s₁) = k
Theorem: Monotone.map_max
File: Mathlib/Order/MinMax.lean

tactic: cases' le_total a b with h h <;> simp [h, hf h]
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
hf : Monotone f
⊢ f (max a b) = max (f a) (f b)
Theorem: multiplicity.Int.pow_add_pow
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: rw [← sub_neg_eq_add] at hxy
state_before: R : Type ?u.836891
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℤ
hxy : ↑p ∣ x + y
hx : ¬↑p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity (↑p) (x ^ n + y ^ n) = multiplicity (↑p) (x + y) + multiplicity p n

tactic: rw [← sub_neg_eq_add, ← sub_neg_eq_add, ← Odd.neg_pow hn]
state_before: R : Type ?u.836891
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℤ
hxy : ↑p ∣ x - -y
hx : ¬↑p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity (↑p) (x ^ n + y ^ n) = multiplicity (↑p) (x + y) + multiplicity p n

tactic: exact Int.pow_sub_pow hp hp1 hxy hx n
state_before: R : Type ?u.836891
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ : R
p : ℕ
hp : Nat.Prime p
hp1 : Odd p
x y : ℤ
hxy : ↑p ∣ x - -y
hx : ¬↑p ∣ x
n : ℕ
hn : Odd n
⊢ multiplicity (↑p) (x ^ n - (-y) ^ n) = multiplicity (↑p) (x - -y) + multiplicity p n
Theorem: Turing.PartrecToTM2.supports_biUnion
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [Supports]
state_before: K : Option Γ' → Finset Λ'
S : Finset Λ'
⊢ Supports (Finset.biUnion Finset.univ K) S ↔ ∀ (a : Option Γ'), Supports (K a) S

tactic: apply forall_swap
state_before: K : Option Γ' → Finset Λ'
S : Finset Λ'
⊢ (∀ (q : Λ') (x : Option Γ'), q ∈ K x → TM2.SupportsStmt S (tr q)) ↔
    ∀ (a : Option Γ') (q : Λ'), q ∈ K a → TM2.SupportsStmt S (tr q)
Theorem: Real.sin_pi_div_six
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_pi_div_two_sub, ← cos_pi_div_three]
state_before: x : ℝ
⊢ sin (π / 6) = 1 / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 2 - π / 6) = cos (π / 3)

tactic: ring
state_before: case e_x
x : ℝ
⊢ π / 2 - π / 6 = π / 3
Theorem: BoxIntegral.Prepartition.card_filter_mem_Icc_le
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: rw [← Fintype.card_set]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
x : ι → ℝ
⊢ card (filter (fun J => x ∈ ↑Box.Icc J) π.boxes) ≤ 2 ^ Fintype.card ι

tactic: refine' Finset.card_le_card_of_inj_on (fun J : Box ι => { i | J.lower i = x i })
  (fun _ _ => Finset.mem_univ _) _
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
x : ι → ℝ
⊢ card (filter (fun J => x ∈ ↑Box.Icc J) π.boxes) ≤ Fintype.card (Set ι)

tactic: simpa only [Finset.mem_filter] using π.injOn_setOf_mem_Icc_setOf_lower_eq x
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
x : ι → ℝ
⊢ ∀ (a₁ : Box ι),
    a₁ ∈ filter (fun J => x ∈ ↑Box.Icc J) π.boxes →
      ∀ (a₂ : Box ι),
        a₂ ∈ filter (fun J => x ∈ ↑Box.Icc J) π.boxes →
          (fun J => {i | Box.lower J i = x i}) a₁ = (fun J => {i | Box.lower J i = x i}) a₂ → a₁ = a₂