1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: AbstractCompletion.uniformContinuous_extend
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

tactic: by_cases hf : UniformContinuous f
state_before: α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
⊢ UniformContinuous (pkg.extend f)
state_after: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (pkg.extend f)

case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (pkg.extend f)

tactic: rw [pkg.extend_def hf]
state_before: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (pkg.extend f)
state_after: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (⋯.extend f)

tactic: exact uniformContinuous_uniformly_extend pkg.uniformInducing pkg.dense hf
state_before: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (⋯.extend f)
state_after: no goals

tactic: change UniformContinuous (ite _ _ _)
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (pkg.extend f)
state_after: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (if UniformContinuous f then ⋯.extend f else fun x => f (⋯.some x))

tactic: rw [if_neg hf]
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (if UniformContinuous f then ⋯.extend f else fun x => f (⋯.some x))
state_after: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous fun x => f (⋯.some x)

tactic: exact uniformContinuous_of_const fun a b => by congr 1
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous fun x => f (⋯.some x)
state_after: no goals

tactic: congr 1
state_before: α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
a b : pkg.space
⊢ f (⋯.some a) = f (⋯.some b)
state_after: no goals
Theorem: Fin.card_Ioo
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: rw [← Nat.card_Ioo, ← map_valEmbedding_Ioo, card_map]
state_before: n : ℕ
a b : Fin n
⊢ (Ioo a b).card = ↑b - ↑a - 1
state_after: no goals
Theorem: Multiset.nodup_keys
File: Mathlib/Data/Finmap.lean

tactic: rcases m with ⟨l⟩
state_before: α : Type u
β : α → Type v
m : Multiset ((a : α) × β a)
⊢ m.keys.Nodup ↔ m.NodupKeys
state_after: case mk
α : Type u
β : α → Type v
m : Multiset ((a : α) × β a)
l : List ((a : α) × β a)
⊢ (keys (Quot.mk Setoid.r l)).Nodup ↔ NodupKeys (Quot.mk Setoid.r l)

tactic: rfl
state_before: case mk
α : Type u
β : α → Type v
m : Multiset ((a : α) × β a)
l : List ((a : α) × β a)
⊢ (keys (Quot.mk Setoid.r l)).Nodup ↔ NodupKeys (Quot.mk Setoid.r l)
state_after: no goals
Theorem: List.reverse_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [← length_reverse l, ← rotate_eq_iff]
state_before: α : Type u
l : List α
n : ℕ
⊢ (l.rotate n).reverse = l.reverse.rotate (l.length - n % l.length)
state_after: α : Type u
l : List α
n : ℕ
⊢ (l.rotate n).reverse.rotate n = l.reverse

tactic: induction' n with n hn generalizing l
state_before: α : Type u
l : List α
n : ℕ
⊢ (l.rotate n).reverse.rotate n = l.reverse
state_after: case zero
α : Type u
l : List α
⊢ (l.rotate 0).reverse.rotate 0 = l.reverse

case succ
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
l : List α
⊢ (l.rotate (n + 1)).reverse.rotate (n + 1) = l.reverse

tactic: simp
state_before: case zero
α : Type u
l : List α
⊢ (l.rotate 0).reverse.rotate 0 = l.reverse
state_after: no goals

tactic: cases' l with hd tl
state_before: case succ
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
l : List α
⊢ (l.rotate (n + 1)).reverse.rotate (n + 1) = l.reverse
state_after: case succ.nil
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
⊢ ([].rotate (n + 1)).reverse.rotate (n + 1) = [].reverse

case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
hd : α
tl : List α
⊢ ((hd :: tl).rotate (n + 1)).reverse.rotate (n + 1) = (hd :: tl).reverse

tactic: simp
state_before: case succ.nil
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
⊢ ([].rotate (n + 1)).reverse.rotate (n + 1) = [].reverse
state_after: no goals

tactic: rw [rotate_cons_succ, ← rotate_rotate, hn]
state_before: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
hd : α
tl : List α
⊢ ((hd :: tl).rotate (n + 1)).reverse.rotate (n + 1) = (hd :: tl).reverse
state_after: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
hd : α
tl : List α
⊢ (tl ++ [hd]).reverse.rotate 1 = (hd :: tl).reverse

tactic: simp
state_before: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), (l.rotate n).reverse.rotate n = l.reverse
hd : α
tl : List α
⊢ (tl ++ [hd]).reverse.rotate 1 = (hd :: tl).reverse
state_after: no goals
Theorem: NumberField.mixedEmbedding_injective
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

tactic: exact RingHom.injective _
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
⊢ Function.Injective ⇑(mixedEmbedding K)
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_nonzero
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [← FiniteMeasure.mass_nonzero_iff, μ.mass_toFiniteMeasure]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ μ.toFiniteMeasure ≠ 0
state_after: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ 1 ≠ 0

tactic: exact one_ne_zero
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
⊢ 1 ≠ 0
state_after: no goals
Theorem: TopCat.GlueData.open_image_open
File: Mathlib/Topology/Gluing.lean

tactic: rw [isOpen_iff]
state_before: D : GlueData
i : D.J
U : Opens ↑(D.U i)
⊢ IsOpen (⇑(D.ι i) '' ↑U)
state_after: D : GlueData
i : D.J
U : Opens ↑(D.U i)
⊢ ∀ (i_1 : D.J), IsOpen (⇑(D.ι i_1) ⁻¹' (⇑(D.ι i) '' ↑U))

tactic: intro j
state_before: D : GlueData
i : D.J
U : Opens ↑(D.U i)
⊢ ∀ (i_1 : D.J), IsOpen (⇑(D.ι i_1) ⁻¹' (⇑(D.ι i) '' ↑U))
state_after: D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.ι j) ⁻¹' (⇑(D.ι i) '' ↑U))

tactic: rw [preimage_image_eq_image]
state_before: D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.ι j) ⁻¹' (⇑(D.ι i) '' ↑U))
state_after: D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.f j i) '' (⇑(D.t j i ≫ D.f i j) ⁻¹' ↑U))

tactic: apply (D.f_open _ _).isOpenMap
state_before: D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.f j i) '' (⇑(D.t j i ≫ D.f i j) ⁻¹' ↑U))
state_after: case a
D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.t j i ≫ D.f i j) ⁻¹' ↑U)

tactic: apply (D.t j i ≫ D.f i j).continuous_toFun.isOpen_preimage
state_before: case a
D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen (⇑(D.t j i ≫ D.f i j) ⁻¹' ↑U)
state_after: case a.a
D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen ↑U

tactic: exact U.isOpen
state_before: case a.a
D : GlueData
i : D.J
U : Opens ↑(D.U i)
j : D.J
⊢ IsOpen ↑U
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_add_singularPart
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [add_comm, singularPart_add_rnDeriv]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
⊢ ν.withDensity (μ.rnDeriv ν) + μ.singularPart ν = μ
state_after: no goals
Theorem: Polynomial.eraseLead_support
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: simp only [eraseLead, support_erase]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ f.eraseLead.support = f.support.erase f.natDegree
state_after: no goals
Theorem: ENNReal.embedding_coe
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [range_coe']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ (range ofNNReal).OrdConnected
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ (Iio ⊤).OrdConnected

tactic: exact ordConnected_Iio
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ (Iio ⊤).OrdConnected
state_after: no goals
Theorem: Set.biUnion_Ioc_eq_Ioi_self_iff
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
⊢ ⋃ i, ⋃ (hi : p i), Ioc a (f i hi) = Ioi a ↔ ∀ (x : α), a < x → ∃ i, ∃ (hi : p i), x ≤ f i hi
state_after: no goals
Theorem: IsOfFinOrder.orderOf_pow
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: unfold orderOf
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ orderOf (x ^ n) = orderOf x / (orderOf x).gcd n
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n

tactic: rw [← minimalPeriod_iterate_eq_div_gcd' h, mul_left_iterate]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
state_after: no goals
Theorem: Pi.lex_lt_of_lt
File: Mathlib/Order/PiLex.lean

tactic: simp_rw [Pi.Lex, le_antisymm_iff]
state_before: ι : Type u_1
β : ι → Type u_2
r✝ : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : (i : ι) → PartialOrder (β i)
r : ι → ι → Prop
hwf : WellFounded r
x y : (i : ι) → β i
hlt : x < y
⊢ Pi.Lex r (fun i x x_1 => x < x_1) x y
state_after: ι : Type u_1
β : ι → Type u_2
r✝ : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : (i : ι) → PartialOrder (β i)
r : ι → ι → Prop
hwf : WellFounded r
x y : (i : ι) → β i
hlt : x < y
⊢ ∃ i, (∀ (j : ι), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i

tactic: exact lex_lt_of_lt_of_preorder hwf hlt
state_before: ι : Type u_1
β : ι → Type u_2
r✝ : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : (i : ι) → PartialOrder (β i)
r : ι → ι → Prop
hwf : WellFounded r
x y : (i : ι) → β i
hlt : x < y
⊢ ∃ i, (∀ (j : ι), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
state_after: no goals
Theorem: MeasureTheory.weightedSMul_apply
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp [weightedSMul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
s : Set α
x : F
⊢ (weightedSMul μ s) x = (μ s).toReal • x
state_after: no goals
Theorem: CategoryTheory.Localization.Preadditive.add'_left_neg'
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

tactic: obtain ⟨α, rfl⟩ := exists_leftFraction L W f
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
⊢ add' W (neg' W f) f = L.map 0
state_after: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
⊢ add' W (neg' W (α.map L ⋯)) (α.map L ⋯) = L.map 0

tactic: have := inverts L W _ α.hs
state_before: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
⊢ add' W (neg' W (α.map L ⋯)) (α.map L ⋯) = L.map 0
state_after: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
this : IsIso (L.map α.s)
⊢ add' W (neg' W (α.map L ⋯)) (α.map L ⋯) = L.map 0

tactic: rw [add'_eq W _ _ (LeftFraction₂.mk (-α.f) α.f α.s α.hs) (neg'_eq W _ _ rfl) rfl]
state_before: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
this : IsIso (L.map α.s)
⊢ add' W (neg' W (α.map L ⋯)) (α.map L ⋯) = L.map 0
state_after: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
this : IsIso (L.map α.s)
⊢ (LeftFraction₂.mk (-α.f) α.f α.s ⋯).add.map L ⋯ = L.map 0

tactic: simp only [← cancel_mono (L.map α.s), LeftFraction.map_comp_map_s, ← L.map_comp,
  Limits.zero_comp, add_left_neg]
state_before: case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
α : W.LeftFraction X Y
this : IsIso (L.map α.s)
⊢ (LeftFraction₂.mk (-α.f) α.f α.s ⋯).add.map L ⋯ = L.map 0
state_after: no goals
Theorem: Ideal.pow_mem_of_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: decide
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
ha : a ∈ I
n : ℕ
hn : 0 < n
⊢ ¬0 < Nat.zero
state_after: no goals
Theorem: Topology.IsLower.continuous_iff_Ici
File: Mathlib/Topology/Order/LowerUpperTopology.lean

tactic: obtain rfl := IsLower.topology_eq α
state_before: α : Type u_2
β : Type u_1
inst✝³ : Preorder α
inst✝² : TopologicalSpace α
inst✝¹ : IsLower α
s : Set α
inst✝ : TopologicalSpace β
f : β → α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)
state_after: α : Type u_2
β : Type u_1
inst✝² : Preorder α
s : Set α
inst✝¹ : TopologicalSpace β
f : β → α
inst✝ : IsLower α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)

tactic: simp [continuous_generateFrom_iff]
state_before: α : Type u_2
β : Type u_1
inst✝² : Preorder α
s : Set α
inst✝¹ : TopologicalSpace β
f : β → α
inst✝ : IsLower α
⊢ Continuous f ↔ ∀ (a : α), IsClosed (f ⁻¹' Ici a)
state_after: no goals
Theorem: CliffordAlgebraQuaternion.ofQuaternion_star
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

tactic: rw [equiv_apply, equiv_apply, toQuaternion_star, toQuaternion_ofQuaternion,
  toQuaternion_ofQuaternion]
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
q : ℍ[R,c₁,c₂]
⊢ CliffordAlgebraQuaternion.equiv (ofQuaternion (star q)) = CliffordAlgebraQuaternion.equiv (star (ofQuaternion q))
state_after: no goals
Theorem: Subgroup.closure_le_normalClosure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simp only [subset_normalClosure, closure_le]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
s✝ s : Set G
⊢ closure s ≤ normalClosure s
state_after: no goals
Theorem: List.destutter'_is_chain'
File: Mathlib/Data/List/Destutter.lean

tactic: induction' l with b l hl generalizing a
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b a : α
⊢ Chain' R (destutter' R a l)
state_after: case nil
α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b a : α
⊢ Chain' R (destutter' R a [])

case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
⊢ Chain' R (destutter' R a (b :: l))

tactic: rw [destutter']
state_before: case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
⊢ Chain' R (destutter' R a (b :: l))
state_after: case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
⊢ Chain' R (if R a b then a :: destutter' R b l else destutter' R a l)

tactic: split_ifs with h
state_before: case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
⊢ Chain' R (if R a b then a :: destutter' R b l else destutter' R a l)
state_after: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
h : R a b
⊢ Chain' R (a :: destutter' R b l)

case neg
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
h : ¬R a b
⊢ Chain' R (destutter' R a l)

tactic: simp
state_before: case nil
α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b a : α
⊢ Chain' R (destutter' R a [])
state_after: no goals

tactic: exact destutter'_is_chain R l h
state_before: case pos
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
h : R a b
⊢ Chain' R (a :: destutter' R b l)
state_after: no goals

tactic: exact hl a
state_before: case neg
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ b : α
l : List α
hl : ∀ (a : α), Chain' R (destutter' R a l)
a : α
h : ¬R a b
⊢ Chain' R (destutter' R a l)
state_after: no goals
Theorem: Filter.HasBasis.inf_principal
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_inf_principal, hl.mem_iff, subset_def, mem_setOf_eq, mem_inter_iff, and_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : l.HasBasis p s
s' t : Set α
⊢ t ∈ l ⊓ 𝓟 s' ↔ ∃ i, p i ∧ s i ∩ s' ⊆ t
state_after: no goals
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_right_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [← cancel_mono (f ◁ (λ_ g).hom)]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ f).inv ▷ g ≫ (α_ f (𝟙 b) g).hom = f ◁ (λ_ g).inv
state_after: no goals
Theorem: Batteries.DList.toList_empty
File: Mathlib/Data/DList/Defs.lean

tactic: simp
state_before: α : Type u
⊢ empty.toList = []
state_after: no goals
Theorem: Matrix.mulVec_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
⊢ A *ᵥ 0 = 0
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
x✝ : m
⊢ (A *ᵥ 0) x✝ = 0 x✝

tactic: simp [mulVec]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
x✝ : m
⊢ (A *ᵥ 0) x✝ = 0 x✝
state_after: no goals
Theorem: FormalMultilinearSeries.zero_radius
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rw [← constFormalMultilinearSeries_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
⊢ radius 0 = ⊤
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
⊢ (constFormalMultilinearSeries 𝕜 E 0).radius = ⊤

tactic: exact constFormalMultilinearSeries_radius
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
⊢ (constFormalMultilinearSeries 𝕜 E 0).radius = ⊤
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.restrict_sInf_eq_sInf_restrict
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: simp only [sInf_eq_iInf, restrict_biInf, hm, iInf_image]
state_before: α : Type u_1
m : Set (OuterMeasure α)
s : Set α
hm : m.Nonempty
⊢ (restrict s) (sInf m) = sInf (⇑(restrict s) '' m)
state_after: no goals
Theorem: IsUnit.inv_mul_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rintro ⟨u, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
⊢ IsUnit a → a⁻¹ * a = 1
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1

tactic: rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1
state_after: no goals
Theorem: mul_eq_of_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = c / b
⊢ a * b = c
state_after: no goals
Theorem: CategoryTheory.Iso.homCongr_apply
File: Mathlib/CategoryTheory/Conj.lean

tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ (α.homCongr β) f = α.inv ≫ f ≫ β.hom
state_after: no goals