1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.cons_vec_bit1_eq_alt1
File: Mathlib/Data/Fin/VecNotation.lean

tactic: rw [vecAlt1_vecAppend]
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit1 i) = vecAlt1 ⋯ (vecAppend ⋯ (vecCons x u) (vecCons x u)) i
state_after: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit1 i) = (vecCons x u ∘ bit1) i

tactic: rfl
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin n → α
i : Fin (n + 1)
⊢ vecCons x u (bit1 i) = (vecCons x u ∘ bit1) i
state_after: no goals
Theorem: AlgebraicGeometry.SheafedSpace.IsOpenImmersion.invApp_app
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: simp [Opens.map, Set.preimage_image_eq _ H.base_open.inj]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ { unop := U } = (Opens.map f.base).op.obj { unop := (opensFunctor f).obj U }
state_after: no goals
Theorem: PMF.toOuterMeasure_map_apply
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [map, Set.indicator, toOuterMeasure_apply p (f ⁻¹' s)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
p : PMF α
b : β
s : Set β
⊢ (map f p).toOuterMeasure s = p.toOuterMeasure (f ⁻¹' s)
state_after: no goals
Theorem: OrderEmbedding.birkhoffSet_inf
File: Mathlib/Order/Birkhoff.lean

tactic: unfold OrderEmbedding.birkhoffSet
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ birkhoffSet (a ⊓ b) = birkhoffSet a ∩ birkhoffSet b
state_after: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ (if h : IsEmpty α then ofIsEmpty
      else
        let_fun this := Fintype.toOrderBot α;
        RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
          { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
      (a ⊓ b) =
    (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        a ∩
      (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        b

tactic: split <;> simp [eq_iff_true_of_subsingleton]
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ (if h : IsEmpty α then ofIsEmpty
      else
        let_fun this := Fintype.toOrderBot α;
        RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
          { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
      (a ⊓ b) =
    (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        a ∩
      (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        b
state_after: no goals
Theorem: SimpleGraph.ConnectedComponent.map_id
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine C.ind ?_
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
C : G.ConnectedComponent
⊢ map Hom.id C = C
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
C : G.ConnectedComponent
⊢ ∀ (v : V), map Hom.id (G.connectedComponentMk v) = G.connectedComponentMk v

tactic: exact fun _ => rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
C : G.ConnectedComponent
⊢ ∀ (v : V), map Hom.id (G.connectedComponentMk v) = G.connectedComponentMk v
state_after: no goals
Theorem: invOf_div
File: Mathlib/Algebra/GroupWithZero/Invertible.lean

tactic: simp [← mul_div_assoc]
state_before: α : Type u
inst✝³ : GroupWithZero α
a b : α
inst✝² : Invertible a
inst✝¹ : Invertible b
inst✝ : Invertible (a / b)
⊢ a / b * (b / a) = 1
state_after: no goals
Theorem: CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst_eq_pullback_snd
File: Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean

tactic: convert (eq_whisker pullback.condition Limits.prod.fst :
    (_ : constructEqualizer F ⟶ F.obj WalkingParallelPair.zero) = _) <;> simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F = pullback.snd
state_after: no goals
Theorem: Set.bijOn_empty_iff_left
File: Mathlib/Data/Set/Function.lean

tactic: simpa using h.mapsTo
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h : BijOn f s ∅
⊢ s = ∅
state_after: no goals

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ s = ∅ → BijOn f s ∅
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ BijOn f ∅ ∅

tactic: exact bijOn_empty f
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ BijOn f ∅ ∅
state_after: no goals
Theorem: IsGalois.card_fixingSubgroup_eq_finrank
File: Mathlib/FieldTheory/Galois.lean

tactic: conv_rhs => rw [← fixedField_fixingSubgroup K, IntermediateField.finrank_fixedField_eq_card]
state_before: F : Type u_1
inst✝⁵ : Field F
E : Type u_2
inst✝⁴ : Field E
inst✝³ : Algebra F E
H : Subgroup (E ≃ₐ[F] E)
K : IntermediateField F E
inst✝² : DecidablePred fun x => x ∈ K.fixingSubgroup
inst✝¹ : FiniteDimensional F E
inst✝ : IsGalois F E
⊢ Fintype.card ↥K.fixingSubgroup = finrank (↥K) E
state_after: no goals
Theorem: strictMono_restrict
File: Mathlib/Data/Set/Function.lean

tactic: simp [Set.restrict, StrictMono, StrictMonoOn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ StrictMono (s.restrict f) ↔ StrictMonoOn f s
state_after: no goals
Theorem: CategoryTheory.isPreconnected_of_zigzag
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: apply zigzag_isPreconnected
state_before: J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ IsPreconnected J
state_after: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ ∀ (j₁ j₂ : J), Zigzag j₁ j₂

tactic: intro j₁ j₂
state_before: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
⊢ ∀ (j₁ j₂ : J), Zigzag j₁ j₂
state_after: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
⊢ Zigzag j₁ j₂

tactic: rcases h j₁ j₂ with ⟨l, hl₁, hl₂⟩
state_before: case h
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
⊢ Zigzag j₁ j₂
state_after: case h.intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
l : List J
hl₁ : List.Chain Zag j₁ l
hl₂ : (j₁ :: l).getLast ⋯ = j₂
⊢ Zigzag j₁ j₂

tactic: apply List.relationReflTransGen_of_exists_chain l hl₁ hl₂
state_before: case h.intro.intro
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
h : ∀ (j₁ j₂ : J), ∃ l, List.Chain Zag j₁ l ∧ (j₁ :: l).getLast ⋯ = j₂
j₁ j₂ : J
l : List J
hl₁ : List.Chain Zag j₁ l
hl₂ : (j₁ :: l).getLast ⋯ = j₂
⊢ Zigzag j₁ j₂
state_after: no goals
Theorem: rank_span_finset_le
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: simpa using rank_span_le s.toSet
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁸ : Ring R
inst✝⁷ : CommRing S
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : StrongRankCondition R
s : Finset M
⊢ Module.rank R ↥(span R ↑s) ≤ ↑s.card
state_after: no goals
Theorem: List.Perm.foldr_eq
File: Mathlib/Data/List/Perm.lean

tactic: intro b
state_before: α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
p : l₁ ~ l₂
⊢ ∀ (b : β), foldr f b l₁ = foldr f b l₂
state_after: α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
p : l₁ ~ l₂
b : β
⊢ foldr f b l₁ = foldr f b l₂

tactic: induction p using Perm.recOnSwap' generalizing b with
| nil => rfl
| cons _ _ r  => simp; rw [r b]
| swap' _ _ _ r => simp; rw [lcomm, r b]
| trans _ _ r₁ r₂ => exact Eq.trans (r₁ b) (r₂ b)
state_before: α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
p : l₁ ~ l₂
b : β
⊢ foldr f b l₁ = foldr f b l₂
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
b : β
⊢ foldr f b [] = foldr f b []
state_after: no goals

tactic: simp
state_before: case cons
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ foldr f b (x✝ :: l₁✝) = foldr f b (x✝ :: l₂✝)
state_after: case cons
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ f x✝ (foldr f b l₁✝) = f x✝ (foldr f b l₂✝)

tactic: rw [r b]
state_before: case cons
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ f x✝ (foldr f b l₁✝) = f x✝ (foldr f b l₂✝)
state_after: no goals

tactic: simp
state_before: case swap'
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ y✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ foldr f b (y✝ :: x✝ :: l₁✝) = foldr f b (x✝ :: y✝ :: l₂✝)
state_after: case swap'
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ y✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ f y✝ (f x✝ (foldr f b l₁✝)) = f x✝ (f y✝ (foldr f b l₂✝))

tactic: rw [lcomm, r b]
state_before: case swap'
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
x✝ y✝ : α
l₁✝ l₂✝ : List α
h✝ : l₁✝ ~ l₂✝
r : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
b : β
⊢ f y✝ (f x✝ (foldr f b l₁✝)) = f x✝ (f y✝ (foldr f b l₂✝))
state_after: no goals

tactic: exact Eq.trans (r₁ b) (r₂ b)
state_before: case trans
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
f : α → β → β
l₁ l₂ : List α
lcomm : LeftCommutative f
l₁✝ l₂✝ l₃✝ : List α
h₁✝ : l₁✝ ~ l₂✝
h₂✝ : l₂✝ ~ l₃✝
r₁ : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝
r₂ : ∀ (b : β), foldr f b l₂✝ = foldr f b l₃✝
b : β
⊢ foldr f b l₁✝ = foldr f b l₃✝
state_after: no goals
Theorem: Ideal.eq_zero_of_constant_mem_of_maximal
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: refine Classical.by_contradiction fun hx0 => hI.ne_top ((eq_top_iff_one I).2 ?_)
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
⊢ x = 0
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I

tactic: obtain ⟨y, hy⟩ := hR.mul_inv_cancel hx0
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I
state_after: case intro
R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 ∈ I

tactic: convert I.mul_mem_left (C y) hx
state_before: case intro
R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 ∈ I
state_after: case h.e'_4
R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 = C y * C x

tactic: rw [← C.map_mul, hR.mul_comm y x, hy, RingHom.map_one]
state_before: case h.e'_4
R : Type u
S : Type u_1
inst✝ : Ring R
hR : IsField R
I : Ideal R[X]
hI : I.IsMaximal
x : R
hx : C x ∈ I
hx0 : ¬x = 0
y : R
hy : x * y = 1
⊢ 1 = C y * C x
state_after: no goals
Theorem: IsGδ.dense_biUnion_interior_of_closed
File: Mathlib/Topology/Baire/Lemmas.lean

tactic: haveI := ht.to_subtype
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
t : Set α
s : Set X
hs : IsGδ s
hd : Dense s
ht : t.Countable
f : α → Set X
hc : ∀ i ∈ t, IsClosed (f i)
hU : s ⊆ ⋃ i ∈ t, f i
⊢ Dense (⋃ i ∈ t, interior (f i))
state_after: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
t : Set α
s : Set X
hs : IsGδ s
hd : Dense s
ht : t.Countable
f : α → Set X
hc : ∀ i ∈ t, IsClosed (f i)
hU : s ⊆ ⋃ i ∈ t, f i
this : Countable ↑t
⊢ Dense (⋃ i ∈ t, interior (f i))

tactic: simp only [biUnion_eq_iUnion, SetCoe.forall'] at *
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
t : Set α
s : Set X
hs : IsGδ s
hd : Dense s
ht : t.Countable
f : α → Set X
hc : ∀ i ∈ t, IsClosed (f i)
hU : s ⊆ ⋃ i ∈ t, f i
this : Countable ↑t
⊢ Dense (⋃ i ∈ t, interior (f i))
state_after: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
t : Set α
s : Set X
hs : IsGδ s
hd : Dense s
ht : t.Countable
f : α → Set X
this : Countable ↑t
hc : ∀ (x : ↑t), IsClosed (f ↑x)
hU : s ⊆ ⋃ x, f ↑x
⊢ Dense (⋃ x, interior (f ↑x))

tactic: exact hs.dense_iUnion_interior_of_closed hd hc hU
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
t : Set α
s : Set X
hs : IsGδ s
hd : Dense s
ht : t.Countable
f : α → Set X
this : Countable ↑t
hc : ∀ (x : ↑t), IsClosed (f ↑x)
hU : s ⊆ ⋃ x, f ↑x
⊢ Dense (⋃ x, interior (f ↑x))
state_after: no goals
Theorem: SimpleGraph.isTuranMaximal_of_iso
File: Mathlib/Combinatorics/SimpleGraph/Turan.lean

tactic: obtain ⟨J, _, j⟩ := exists_isTuranMaximal (V := V) hr
state_before: V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
⊢ G.IsTuranMaximal r
state_after: case intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
⊢ G.IsTuranMaximal r

tactic: obtain ⟨g⟩ := j.nonempty_iso_turanGraph
state_before: case intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
⊢ G.IsTuranMaximal r
state_after: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph (Fintype.card V) r
⊢ G.IsTuranMaximal r

tactic: rw [f.card_eq, Fintype.card_fin] at g
state_before: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph (Fintype.card V) r
⊢ G.IsTuranMaximal r
state_after: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph n r
⊢ G.IsTuranMaximal r

tactic: use (turanGraph_cliqueFree (n := n) hr).comap f,
  fun H _ cf ↦ (f.symm.comp g).card_edgeFinset_eq ▸ j.2 H cf
state_before: case intro.intro.intro
V : Type u_1
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n r : ℕ
f : G ≃g turanGraph n r
hr : 0 < r
J : SimpleGraph V
w✝ : DecidableRel J.Adj
j : J.IsTuranMaximal r
g : J ≃g turanGraph n r
⊢ G.IsTuranMaximal r
state_after: no goals
Theorem: List.getElem_enum
File: Mathlib/Data/List/Enum.lean

tactic: simpa [enum_length] using h
state_before: α : Type u_1
β : Type u_2
l : List α
i : ℕ
h : i < l.enum.length
⊢ i < l.length
state_after: no goals

tactic: simp [enum]
state_before: α : Type u_1
β : Type u_2
l : List α
i : ℕ
h : i < l.enum.length
⊢ l.enum[i] = (i, l[i])
state_after: no goals
Theorem: preNormEDS_one
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: erw [preNormEDS_ofNat, preNormEDS'_one]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS b c d 1 = 1
state_after: no goals
Theorem: MeasureTheory.Martingale.ae_not_tendsto_atTop_atBot
File: Mathlib/Probability/Martingale/BorelCantelli.lean

tactic: filter_upwards [hf.bddAbove_range_iff_bddBelow_range hbdd] with ω hω htop using
  unbounded_of_tendsto_atBot htop (hω.1 <| bddAbove_range_of_tendsto_atTop_atBot htop)
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Martingale f ℱ μ
hbdd : ∀ᵐ (ω : Ω) ∂μ, ∀ (i : ℕ), |f (i + 1) ω - f i ω| ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ¬Tendsto (fun n => f n ω) atTop atBot
state_after: no goals
Theorem: WeierstrassCurve.Affine.CoordinateRing.coe_basis
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

tactic: ext n
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ ⇑(CoordinateRing.basis W) = ![1, (mk W) Y]
state_after: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
n : Fin 2
⊢ (CoordinateRing.basis W) n = ![1, (mk W) Y] n

tactic: fin_cases n
state_before: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
n : Fin 2
⊢ (CoordinateRing.basis W) n = ![1, (mk W) Y] n
state_after: case h.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨0, ⋯⟩ = ![1, (mk W) Y] ⟨0, ⋯⟩

case h.tail.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨1, ⋯⟩ = ![1, (mk W) Y] ⟨1, ⋯⟩

tactic: exacts [basis_zero W, basis_one W]
state_before: case h.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨0, ⋯⟩ = ![1, (mk W) Y] ⟨0, ⋯⟩

case h.tail.head
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
⊢ (CoordinateRing.basis W) ⟨1, ⋯⟩ = ![1, (mk W) Y] ⟨1, ⋯⟩
state_after: no goals
Theorem: vadd_right_cancel
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [← vadd_vsub g₁ p, h, vadd_vsub]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g₁ g₂ : G
p : P
h : g₁ +ᵥ p = g₂ +ᵥ p
⊢ g₁ = g₂
state_after: no goals
Theorem: AffineSubspace.sSameSide_iff_exists_right
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [sSameSide_comm, sSameSide_iff_exists_left h, ← and_assoc, and_comm (a := y ∉ s), and_assoc]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ s.SSameSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ (x ∉ s ∧ y ∉ s ∧ ∃ p₂_1 ∈ s, SameRay R (y -ᵥ p₂) (x -ᵥ p₂_1)) ↔
    x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)

tactic: simp_rw [SameRay.sameRay_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₂ : P
h : p₂ ∈ s
⊢ (x ∉ s ∧ y ∉ s ∧ ∃ p₂_1 ∈ s, SameRay R (y -ᵥ p₂) (x -ᵥ p₂_1)) ↔
    x ∉ s ∧ y ∉ s ∧ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
state_after: no goals
Theorem: IsSubgroup.center_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [center]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ 1 ∈ center G
state_after: no goals

tactic: rw [← mul_assoc, mem_center.2 ha g, mul_assoc, mem_center.2 hb g, ← mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
a✝ b✝ : G
ha : a✝ ∈ center G
hb : b✝ ∈ center G
g : G
⊢ g * (a✝ * b✝) = a✝ * b✝ * g
state_after: no goals

tactic: simp [ha g]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ g * a⁻¹ = a⁻¹ * (g * a) * a⁻¹
state_after: no goals

tactic: rw [← mul_assoc, mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * (g * a) * a⁻¹ = a⁻¹ * g
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * g * (a * a⁻¹) = a⁻¹ * g

tactic: simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * g * (a * a⁻¹) = a⁻¹ * g
state_after: no goals

tactic: simp [ha g, mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * (g * n * g⁻¹) = h * n
state_after: no goals

tactic: rw [ha h]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * n = g * g⁻¹ * n * h
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ n * h = g * g⁻¹ * n * h

tactic: simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ n * h = g * g⁻¹ * n * h
state_after: no goals

tactic: rw [mul_assoc g, ha g⁻¹, ← mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ g * g⁻¹ * n * h = g * n * g⁻¹ * h
state_after: no goals