1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group
File: Mathlib/GroupTheory/GroupAction/Quotient.lean

tactic: rw [← Fintype.card_prod, ← Fintype.card_sigma,
  Fintype.card_congr (sigmaFixedByEquivOrbitsProdGroup α β)]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁵ inst✝⁴ : Group α
inst✝³ : MulAction α β
x : β
inst✝² : Fintype α
inst✝¹ : (a : α) → Fintype ↑(fixedBy β a)
inst✝ : Fintype (Quotient (orbitRel α β))
⊢ ∑ a : α, Fintype.card ↑(fixedBy β a) = Fintype.card (Quotient (orbitRel α β)) * Fintype.card α
state_after: no goals
Theorem: CoxeterSystem.isLeftInversion_simple_iff_isLeftDescent
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: simp [IsLeftInversion, IsLeftDescent, cs.isReflection_simple i]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsLeftInversion w (cs.simple i) ↔ cs.IsLeftDescent w i
state_after: no goals
Theorem: CategoryTheory.Abelian.coimage_image_factorisation
File: Mathlib/CategoryTheory/Abelian/Images.lean

tactic: simp [coimageImageComparison]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ coimage.π f ≫ coimageImageComparison f ≫ image.ι f = f
state_after: no goals
Theorem: Dioph.ext
File: Mathlib/NumberTheory/Dioph.lean

tactic: rwa [← Set.ext H]
state_before: α β γ : Type u
S S' : Set (α → ℕ)
d : Dioph S
H : ∀ (v : α → ℕ), v ∈ S ↔ v ∈ S'
⊢ Dioph S'
state_after: no goals
Theorem: BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: simpa only [TaggedPrepartition.isPartition_iff_iUnion_eq, Prepartition.iUnion_top] using
  l.hasBasis_toFilteriUnion I ⊤
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
⊢ (l.toFilteriUnion I ⊤).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r =>
    {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition}
state_after: no goals
Theorem: QuotientMap.of_quotientMap_compose
File: Mathlib/Topology/Maps.lean

tactic: rw [hgf.right, ← coinduced_compose]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Continuous f
hg : Continuous g
hgf : QuotientMap (g ∘ f)
⊢ inst✝ ≤ coinduced g inst✝¹
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Continuous f
hg : Continuous g
hgf : QuotientMap (g ∘ f)
⊢ coinduced g (coinduced f inst✝²) ≤ coinduced g inst✝¹

tactic: exact coinduced_mono hf.coinduced_le
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Continuous f
hg : Continuous g
hgf : QuotientMap (g ∘ f)
⊢ coinduced g (coinduced f inst✝²) ≤ coinduced g inst✝¹
state_after: no goals
Theorem: Semiquot.get_mem
File: Mathlib/Data/Semiquot.lean

tactic: let ⟨a, h⟩ := exists_mem q
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
⊢ q.get p ∈ q
state_after: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ q.get p ∈ q

tactic: unfold get
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ q.get p ∈ q
state_after: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ q.liftOn id p ∈ q

tactic: rw [liftOn_ofMem q _ _ a h]
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ q.liftOn id p ∈ q
state_after: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ id a ∈ q

tactic: exact h
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
p : q.IsPure
a : α
h : a ∈ q
⊢ id a ∈ q
state_after: no goals
Theorem: conductor_eq_top_of_adjoin_eq_top
File: Mathlib/NumberTheory/KummerDedekind.lean

tactic: simp only [Ideal.eq_top_iff_one, mem_conductor_iff, h, mem_top, forall_const]
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
h : adjoin R {x} = ⊤
⊢ conductor R x = ⊤
state_after: no goals
Theorem: bit1_add'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [add_comm, bit1_add, add_comm]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M✝ : Type u_4
M : Type u
inst✝¹ : AddCommSemigroup M
inst✝ : One M
a b : M
⊢ bit1 (a + b) = bit1 a + bit0 b
state_after: no goals
Theorem: List.pairwise_lt_finRange
File: Mathlib/Data/List/Range.lean

tactic: simp
state_before: α : Type u
n : ℕ
⊢ ∀ x ∈ range n, x < n
state_after: no goals

tactic: simp
state_before: α : Type u
n : ℕ
⊢ ∀ ⦃x : ℕ⦄ (hx : x < n) ⦃y : ℕ⦄ (hy : y < n), x < y → ⟨x, hx⟩ < ⟨y, hy⟩
state_after: no goals
Theorem: WithBot.image_coe_Ioc
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: rw [← preimage_coe_Ioc, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Subset.trans Ioc_subset_Ioi_self <| Ioi_subset_Ioi bot_le)]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Ioc a b = Ioc ↑a ↑b
state_after: no goals
Theorem: Cycle.prev_mem
File: Mathlib/Data/List/Cycle.lean

tactic: rw [← next_reverse_eq_prev, ← mem_reverse_iff]
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
x : α
hx : x ∈ s
⊢ s.prev hs x hx ∈ s
state_after: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
x : α
hx : x ∈ s
⊢ s.reverse.next ⋯ x ⋯ ∈ s.reverse

tactic: apply next_mem
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
x : α
hx : x ∈ s
⊢ s.reverse.next ⋯ x ⋯ ∈ s.reverse
state_after: no goals
Theorem: smul_unitBall_of_pos
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_unitBall hr.ne', Real.norm_of_nonneg hr.le]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε r : ℝ
hr : 0 < r
⊢ r • ball 0 1 = ball 0 r
state_after: no goals
Theorem: Finset.Ioc_subset_Ioc
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioc ha hb
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Ioc a₁ b₁ ⊆ Ioc a₂ b₂
state_after: no goals
Theorem: ProbabilityTheory.kernel.swapRight_apply'
File: Mathlib/Probability/Kernel/Composition.lean

tactic: rw [swapRight_apply, Measure.map_apply measurable_swap hs]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : ↥(kernel α (β × γ))
a : α
s : Set (γ × β)
hs : MeasurableSet s
⊢ ((swapRight κ) a) s = (κ a) {p | p.swap ∈ s}
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : ↥(kernel α (β × γ))
a : α
s : Set (γ × β)
hs : MeasurableSet s
⊢ (κ a) (Prod.swap ⁻¹' s) = (κ a) {p | p.swap ∈ s}

tactic: rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : ↥(kernel α (β × γ))
a : α
s : Set (γ × β)
hs : MeasurableSet s
⊢ (κ a) (Prod.swap ⁻¹' s) = (κ a) {p | p.swap ∈ s}
state_after: no goals
Theorem: Stream'.Seq.destruct_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: unfold cons destruct Functor.map
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ (cons a ⟨f, al⟩).destruct = some (a, ⟨f, al⟩)
state_after: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ instFunctorOption.1 (fun a' => (a', tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩)) (get? ⟨some a :: ↑⟨f, al⟩, ⋯⟩ 0) =
    some (a, ⟨f, al⟩)

tactic: apply congr_arg fun s => some (a, s)
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ instFunctorOption.1 (fun a' => (a', tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩)) (get? ⟨some a :: ↑⟨f, al⟩, ⋯⟩ 0) =
    some (a, ⟨f, al⟩)
state_after: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩ = ⟨f, al⟩

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩ = ⟨f, al⟩
state_after: case a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩) = ↑⟨f, al⟩

tactic: dsimp [tail]
state_before: case a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩) = ↑⟨f, al⟩
state_after: no goals
Theorem: Part.mem_chain_of_mem_ωSup
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp only [Part.ωSup] at h
state_before: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ Part.ωSup c
⊢ some a ∈ c
state_after: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (Classical.choose h) else none
⊢ some a ∈ c

tactic: split_ifs at h with h_1
state_before: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (Classical.choose h) else none
⊢ some a ∈ c
state_after: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (Classical.choose h_1)
⊢ some a ∈ c

case neg
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ¬∃ a, some a ∈ c
h : a ∈ none
⊢ some a ∈ c

tactic: have h' := Classical.choose_spec h_1
state_before: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (Classical.choose h_1)
⊢ some a ∈ c
state_after: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (Classical.choose h_1)
h' : some (Classical.choose h_1) ∈ c
⊢ some a ∈ c

tactic: rw [← eq_some_iff] at h
state_before: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (Classical.choose h_1)
h' : some (Classical.choose h_1) ∈ c
⊢ some a ∈ c
state_after: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (Classical.choose h_1) = some a
h' : some (Classical.choose h_1) ∈ c
⊢ some a ∈ c

tactic: rw [← h]
state_before: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (Classical.choose h_1) = some a
h' : some (Classical.choose h_1) ∈ c
⊢ some a ∈ c
state_after: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (Classical.choose h_1) = some a
h' : some (Classical.choose h_1) ∈ c
⊢ some (Classical.choose h_1) ∈ c

tactic: exact h'
state_before: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (Classical.choose h_1) = some a
h' : some (Classical.choose h_1) ∈ c
⊢ some (Classical.choose h_1) ∈ c
state_after: no goals

tactic: rcases h with ⟨⟨⟩⟩
state_before: case neg
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ¬∃ a, some a ∈ c
h : a ∈ none
⊢ some a ∈ c
state_after: no goals
Theorem: Submodule.annihilator_top_inter_nonZeroDivisors
File: Mathlib/Algebra/Module/Torsion.lean

tactic: obtain ⟨S, hS⟩ := ‹Module.Finite R M›.out
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
⊢ ↑⊤.annihilator ∩ ↑R⁰ ≠ ∅
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑⊤.annihilator ∩ ↑R⁰ ≠ ∅

tactic: refine Set.Nonempty.ne_empty ⟨_, ?_, (∏ x ∈ S, (@hM x).choose : R⁰).prop⟩
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑⊤.annihilator ∩ ↑R⁰ ≠ ∅
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑(∏ x ∈ S, ⋯.choose) ∈ ↑⊤.annihilator

tactic: rw [Submonoid.coe_finset_prod, SetLike.mem_coe, ← hS, mem_annihilator_span]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ↑(∏ x ∈ S, ⋯.choose) ∈ ↑⊤.annihilator
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ∀ (n : ↑↑S), (∏ i ∈ S, ↑⋯.choose) • ↑n = 0

tactic: intro n
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
⊢ ∀ (n : ↑↑S), (∏ i ∈ S, ↑⋯.choose) • ↑n = 0
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
⊢ (∏ i ∈ S, ↑⋯.choose) • ↑n = 0

tactic: letI := Classical.decEq M
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
⊢ (∏ i ∈ S, ↑⋯.choose) • ↑n = 0
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
this : DecidableEq M := Classical.decEq M
⊢ (∏ i ∈ S, ↑⋯.choose) • ↑n = 0

tactic: rw [← Finset.prod_erase_mul _ _ n.prop, mul_smul, ← Submonoid.smul_def, (@hM n).choose_spec,
  smul_zero]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module.Finite R M
hM : Module.IsTorsion R M
S : Finset M
hS : span R ↑S = ⊤
n : ↑↑S
this : DecidableEq M := Classical.decEq M
⊢ (∏ i ∈ S, ↑⋯.choose) • ↑n = 0
state_after: no goals
Theorem: UniformSpace.mem_closure_iff_symm_ball
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [mem_closure_iff_nhds_basis (hasBasis_nhds x), Set.Nonempty]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
s : Set α
x : α
⊢ x ∈ closure s ↔ ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (s ∩ ball x V).Nonempty
state_after: no goals
Theorem: CategoryTheory.Functor.ext_of_iso
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: rw [← cancel_mono (e.hom.app Y), e.hom.naturality f, happ, happ, Category.assoc,
Category.assoc, eqToHom_trans, eqToHom_refl, Category.comp_id]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : C ⥤ D
e : F ≅ G
hobj : ∀ (X : C), F.obj X = G.obj X
happ : ∀ (X : C), e.hom.app X = eqToHom ⋯
X Y : C
f : X ⟶ Y
⊢ F.map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
state_after: no goals
Theorem: AList.lookupFinsupp_eq_zero_iff
File: Mathlib/Data/Finsupp/AList.lean

tactic: rw [lookupFinsupp_apply, ← lookup_eq_none]
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ l.lookupFinsupp a = 0 ↔ a ∉ l ∨ 0 ∈ lookup a l
state_after: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ (lookup a l).getD 0 = 0 ↔ lookup a l = none ∨ 0 ∈ lookup a l

tactic: cases' lookup a l with m <;> simp
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ (lookup a l).getD 0 = 0 ↔ lookup a l = none ∨ 0 ∈ lookup a l
state_after: no goals
Theorem: Language.one_add_self_mul_kstar_eq_kstar
File: Mathlib/Computability/Language.lean

tactic: simp only [kstar_eq_iSup_pow, mul_iSup, ← pow_succ', ← pow_zero l]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ 1 + l * l∗ = l∗
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ l ^ 0 + ⨆ i, l ^ (i + 1) = ⨆ i, l ^ i

tactic: exact sup_iSup_nat_succ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ l ^ 0 + ⨆ i, l ^ (i + 1) = ⨆ i, l ^ i
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.prod_swap
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: apply Subtype.ext
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ (μ.prod ν).map Prod.swap = ν.prod μ
state_after: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ ↑((μ.prod ν).map Prod.swap) = ↑(ν.prod μ)

tactic: simp [Measure.prod_swap]
state_before: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ ↑((μ.prod ν).map Prod.swap) = ↑(ν.prod μ)
state_after: no goals
Theorem: PiNat.exists_retraction_subtype_of_isClosed
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: obtain ⟨f, fs, rfl, f_cont⟩ :
  ∃ f : (∀ n, E n) → ∀ n, E n, (∀ x ∈ s, f x = x) ∧ range f = s ∧ Continuous f :=
  exists_retraction_of_isClosed hs hne
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
hne : s.Nonempty
⊢ ∃ f, (∀ (x : ↑s), f ↑x = x) ∧ Surjective f ∧ Continuous f
state_after: case intro.intro.intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
f : ((n : ℕ) → E n) → (n : ℕ) → E n
f_cont : Continuous f
hs : IsClosed (range f)
hne : (range f).Nonempty
fs : ∀ x ∈ range f, f x = x
⊢ ∃ f_1, (∀ (x : ↑(range f)), f_1 ↑x = x) ∧ Surjective f_1 ∧ Continuous f_1

tactic: have A : ∀ x : range f, rangeFactorization f x = x := fun x ↦ Subtype.eq <| fs x x.2
state_before: case intro.intro.intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
f : ((n : ℕ) → E n) → (n : ℕ) → E n
f_cont : Continuous f
hs : IsClosed (range f)
hne : (range f).Nonempty
fs : ∀ x ∈ range f, f x = x
⊢ ∃ f_1, (∀ (x : ↑(range f)), f_1 ↑x = x) ∧ Surjective f_1 ∧ Continuous f_1
state_after: case intro.intro.intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
f : ((n : ℕ) → E n) → (n : ℕ) → E n
f_cont : Continuous f
hs : IsClosed (range f)
hne : (range f).Nonempty
fs : ∀ x ∈ range f, f x = x
A : ∀ (x : ↑(range f)), rangeFactorization f ↑x = x
⊢ ∃ f_1, (∀ (x : ↑(range f)), f_1 ↑x = x) ∧ Surjective f_1 ∧ Continuous f_1

tactic: exact ⟨rangeFactorization f, A, fun x => ⟨x, A x⟩, f_cont.subtype_mk _⟩
state_before: case intro.intro.intro
E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
f : ((n : ℕ) → E n) → (n : ℕ) → E n
f_cont : Continuous f
hs : IsClosed (range f)
hne : (range f).Nonempty
fs : ∀ x ∈ range f, f x = x
A : ∀ (x : ↑(range f)), rangeFactorization f ↑x = x
⊢ ∃ f_1, (∀ (x : ↑(range f)), f_1 ↑x = x) ∧ Surjective f_1 ∧ Continuous f_1
state_after: no goals
Theorem: UniqueFactorizationMonoid.exists_prime_iff
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: refine ⟨fun ⟨p, hp⟩ ↦ ⟨p, hp.ne_zero, hp.not_unit⟩, fun ⟨x, hx₀, hxu⟩ ↦ ?_⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
⊢ (∃ p, Prime p) ↔ ∃ x, x ≠ 0 ∧ ¬IsUnit x
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x✝ : ∃ x, x ≠ 0 ∧ ¬IsUnit x
x : α
hx₀ : x ≠ 0
hxu : ¬IsUnit x
⊢ ∃ p, Prime p

tactic: obtain ⟨f, hf, -⟩ := WfDvdMonoid.exists_irreducible_factor hxu hx₀
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x✝ : ∃ x, x ≠ 0 ∧ ¬IsUnit x
x : α
hx₀ : x ≠ 0
hxu : ¬IsUnit x
⊢ ∃ p, Prime p
state_after: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x✝ : ∃ x, x ≠ 0 ∧ ¬IsUnit x
x : α
hx₀ : x ≠ 0
hxu : ¬IsUnit x
f : α
hf : Irreducible f
⊢ ∃ p, Prime p

tactic: exact ⟨f, UniqueFactorizationMonoid.irreducible_iff_prime.mp hf⟩
state_before: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x✝ : ∃ x, x ≠ 0 ∧ ¬IsUnit x
x : α
hx₀ : x ≠ 0
hxu : ¬IsUnit x
f : α
hf : Irreducible f
⊢ ∃ p, Prime p
state_after: no goals
Theorem: Metric.tendstoUniformlyOn_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: refine ⟨fun H ε hε => H _ (dist_mem_uniformity hε), fun H u hu => ?_⟩
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
⊢ TendstoUniformlyOn F f p s ↔ ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, dist (f x) (F n x) < ε
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, dist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u

tactic: rcases mem_uniformity_dist.1 hu with ⟨ε, εpos, hε⟩
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, dist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, dist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u

tactic: exact (H ε εpos).mono fun n hs x hx => hε (hs x hx)
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, dist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: no goals
Theorem: FreeGroup.equivalence_join_red
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflGen Red.Step b b
state_after: no goals

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflTransGen Red.Step b b
state_after: no goals
Theorem: LinearMap.isAdjointPair_zero
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: simp only [zero_apply, map_zero]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : Module R M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
I : R →+* R
B F : M →ₗ[R] M →ₛₗ[I] M₃
B' : M₁ →ₗ[R] M₁ →ₛₗ[I] M₃
B'' : M₂ →ₗ[R] M₂ →ₛₗ[I] M₃
f f' : M →ₗ[R] M₁
g g' : M₁ →ₗ[R] M
x✝¹ : M
x✝ : M₁
⊢ (B' (0 x✝¹)) x✝ = (B x✝¹) (0 x✝)
state_after: no goals