1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CompleteLattice.Independent.subtype_ne_bot_le_finrank_aux
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: suffices Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{v} (finrank R M : Cardinal.{w}) by
  rwa [Cardinal.lift_le] at this
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ #{ i // p i ≠ ⊥ } ≤ ↑(finrank R M)
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{v, w} #{ i // p i ≠ ⊥ } ≤ lift.{v, w} ↑(finrank R M)

tactic: calc
  Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{w} (Module.rank R M) :=
    hp.subtype_ne_bot_le_rank
  _ = Cardinal.lift.{w} (finrank R M : Cardinal.{v}) := by rw [finrank_eq_rank]
  _ = Cardinal.lift.{v} (finrank R M : Cardinal.{w}) := by simp
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{v, w} #{ i // p i ≠ ⊥ } ≤ lift.{v, w} ↑(finrank R M)
state_after: no goals

tactic: rwa [Cardinal.lift_le] at this
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
this : lift.{v, w} #{ i // p i ≠ ⊥ } ≤ lift.{v, w} ↑(finrank R M)
⊢ #{ i // p i ≠ ⊥ } ≤ ↑(finrank R M)
state_after: no goals

tactic: rw [finrank_eq_rank]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{w, v} (Module.rank R M) = lift.{w, v} ↑(finrank R M)
state_after: no goals

tactic: simp
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
⊢ lift.{w, v} ↑(finrank R M) = lift.{v, w} ↑(finrank R M)
state_after: no goals
Theorem: aux
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: rw [← φ.image_symm, ← φ.symm.image_interior, image_nonempty]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
α : Type u_6
β : Type u_7
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
φ : α ≃ₜ β
s : Set β
⊢ (interior s).Nonempty ↔ (interior (⇑φ ⁻¹' s)).Nonempty
state_after: no goals
Theorem: skewAdjoint.isStarNormal_of_mem
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [mem_iff] at hx
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
⊢ Commute (star x) x
state_after: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : star x = -x
⊢ Commute (star x) x

tactic: simp only [hx, Commute.neg_left, Commute.refl]
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : star x = -x
⊢ Commute (star x) x
state_after: no goals
Theorem: FractionalIdeal.mapEquiv_refl
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: simp
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
x : FractionalIdeal S P
⊢ (mapEquiv AlgEquiv.refl) x = (RingEquiv.refl (FractionalIdeal S P)) x
state_after: no goals
Theorem: Batteries.UnionFind.linkAux_size
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: simp [linkAux]
state_before: self : Array UFNode
x y : Fin self.size
⊢ (linkAux self x y).size = self.size
state_after: self : Array UFNode
x y : Fin self.size
⊢ (if ↑x = ↑y then self
      else
        if self[↑y].rank < self[↑x].rank then self.set y { parent := ↑x, rank := self[↑y].rank }
        else
          if self[↑x].rank = self[↑y].rank then
            (self.set x { parent := ↑y, rank := self[↑x].rank }).set ⟨↑y, ⋯⟩
              { parent := self[↑y].parent, rank := self[↑y].rank + 1 }
          else self.set x { parent := ↑y, rank := self[↑x].rank }).size =
    self.size

tactic: split <;> [rfl; split] <;> [skip; split] <;> simp
state_before: self : Array UFNode
x y : Fin self.size
⊢ (if ↑x = ↑y then self
      else
        if self[↑y].rank < self[↑x].rank then self.set y { parent := ↑x, rank := self[↑y].rank }
        else
          if self[↑x].rank = self[↑y].rank then
            (self.set x { parent := ↑y, rank := self[↑x].rank }).set ⟨↑y, ⋯⟩
              { parent := self[↑y].parent, rank := self[↑y].rank + 1 }
          else self.set x { parent := ↑y, rank := self[↑x].rank }).size =
    self.size
state_after: no goals
Theorem: WeierstrassCurve.Affine.map_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: simp only [polynomialY]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ (map W f).toAffine.polynomialY = Polynomial.map (mapRingHom f) W.polynomialY
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C 2) * Y + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (C (C 2) * Y + C (C W.a₁ * X + C W.a₃))

tactic: map_simp
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C 2) * Y + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (C (C 2) * Y + C (C W.a₁ * X + C W.a₃))
state_after: no goals
Theorem: CategoryTheory.Presheaf.isLocallyInjective_of_isLocallyInjective
File: Mathlib/CategoryTheory/Sites/LocallyInjective.lean

tactic: simp [h]
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ F₃ : Cᵒᵖ ⥤ D
φ : F₁ ⟶ F₂
ψ : F₂ ⟶ F₃
inst✝ : IsLocallyInjective J (φ ≫ ψ)
X : Cᵒᵖ
x y : (forget D).obj (F₁.obj X)
h : (φ.app X) x = (φ.app X) y
⊢ ((φ ≫ ψ).app X) x = ((φ ≫ ψ).app X) y
state_after: no goals
Theorem: MeasureTheory.hitting_mem_set_of_hitting_lt
File: Mathlib/Probability/Process/HittingTime.lean

tactic: by_cases h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
⊢ u (hitting u s n m ω) ω ∈ s
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s

tactic: exact hitting_mem_set h
state_before: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s
state_after: no goals

tactic: simp_rw [hitting, if_neg h] at hl
state_before: case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s
state_after: case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
hl : m < m
⊢ u (hitting u s n m ω) ω ∈ s

tactic: exact False.elim (hl.ne rfl)
state_before: case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
hl : m < m
⊢ u (hitting u s n m ω) ω ∈ s
state_after: no goals
Theorem: Submodule.span_sup
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [Submodule.span_union, p.span_eq]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ span R s ⊔ p = span R (s ∪ ↑p)
state_after: no goals
Theorem: List.zipWith_swap_prod_support
File: Mathlib/GroupTheory/Perm/List.lean

tactic: intro x hx
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
⊢ (zipWith swap l l').prod.support ≤ l.toFinset ⊔ l'.toFinset
state_after: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
x : α
hx : x ∈ (zipWith swap l l').prod.support
⊢ x ∈ l.toFinset ⊔ l'.toFinset

tactic: have hx' : x ∈ { x | (zipWith swap l l').prod x ≠ x } := by simpa using hx
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
x : α
hx : x ∈ (zipWith swap l l').prod.support
⊢ x ∈ l.toFinset ⊔ l'.toFinset
state_after: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
x : α
hx : x ∈ (zipWith swap l l').prod.support
hx' : x ∈ {x | (zipWith swap l l').prod x ≠ x}
⊢ x ∈ l.toFinset ⊔ l'.toFinset

tactic: simpa using zipWith_swap_prod_support' _ _ hx'
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
x : α
hx : x ∈ (zipWith swap l l').prod.support
hx' : x ∈ {x | (zipWith swap l l').prod x ≠ x}
⊢ x ∈ l.toFinset ⊔ l'.toFinset
state_after: no goals

tactic: simpa using hx
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
inst✝ : Fintype α
l l' : List α
x : α
hx : x ∈ (zipWith swap l l').prod.support
⊢ x ∈ {x | (zipWith swap l l').prod x ≠ x}
state_after: no goals
Theorem: isConnected_setOf_sameRay
File: Mathlib/Analysis/Convex/Normed.lean

tactic: by_cases hx : x = 0
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
⊢ IsConnected {y | SameRay ℝ x y}
state_after: case pos
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : x = 0
⊢ IsConnected {y | SameRay ℝ x y}

case neg
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | SameRay ℝ x y}

tactic: simp_rw [← exists_nonneg_left_iff_sameRay hx]
state_before: case neg
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | SameRay ℝ x y}
state_after: case neg
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | ∃ r, 0 ≤ r ∧ r • x = y}

tactic: exact isConnected_Ici.image _ (continuous_id.smul continuous_const).continuousOn
state_before: case neg
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | ∃ r, 0 ≤ r ∧ r • x = y}
state_after: no goals

tactic: simpa [hx] using isConnected_univ (α := E)
state_before: case pos
ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
x : E
hx : x = 0
⊢ IsConnected {y | SameRay ℝ x y}
state_after: no goals
Theorem: NormedAddGroupHom.ker_zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
⊢ ker 0 = ⊤
state_after: case h
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ x✝ ∈ ker 0 ↔ x✝ ∈ ⊤

tactic: simp [mem_ker]
state_before: case h
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ x✝ ∈ ker 0 ↔ x✝ ∈ ⊤
state_after: no goals
Theorem: Function.FromTypes.uncurry_curry
File: Mathlib/Data/Fin/Tuple/Curry.lean

tactic: ext args
state_before: n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
⊢ (curry f).uncurry = f
state_after: case h
n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
args : (i : Fin n) → p i
⊢ (curry f).uncurry args = f args

tactic: induction n with
| zero => exact congrArg f (Subsingleton.allEq _ _)
| succ n ih => exact Eq.trans (ih _ _) (congrArg f (Fin.cons_self_tail args))
state_before: case h
n : ℕ
p : Fin n → Type u
τ : Type u
f : ((i : Fin n) → p i) → τ
args : (i : Fin n) → p i
⊢ (curry f).uncurry args = f args
state_after: no goals

tactic: exact congrArg f (Subsingleton.allEq _ _)
state_before: case h.zero
τ : Type u
p : Fin 0 → Type u
f : ((i : Fin 0) → p i) → τ
args : (i : Fin 0) → p i
⊢ (curry f).uncurry args = f args
state_after: no goals

tactic: exact Eq.trans (ih _ _) (congrArg f (Fin.cons_self_tail args))
state_before: case h.succ
τ : Type u
n : ℕ
ih : ∀ {p : Fin n → Type u} (f : ((i : Fin n) → p i) → τ) (args : (i : Fin n) → p i), (curry f).uncurry args = f args
p : Fin (n + 1) → Type u
f : ((i : Fin (n + 1)) → p i) → τ
args : (i : Fin (n + 1)) → p i
⊢ (curry f).uncurry args = f args
state_after: no goals
Theorem: not_bddAbove_iff'
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [BddAbove, upperBounds, Set.Nonempty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ ¬BddAbove s ↔ ∀ (x : α), ∃ y ∈ s, ¬y ≤ x
state_after: no goals
Theorem: MulAction.stabilizer_mul_self
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

tactic: ext
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Set G
⊢ ↑(stabilizer G s) * s = s
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Set G
x✝ : G
⊢ x✝ ∈ ↑(stabilizer G s) * s ↔ x✝ ∈ s

tactic: refine ⟨?_, fun h ↦ ⟨_, (stabilizer G s).one_mem, _, h, one_mul _⟩⟩
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Set G
x✝ : G
⊢ x✝ ∈ ↑(stabilizer G s) * s ↔ x✝ ∈ s
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Set G
x✝ : G
⊢ x✝ ∈ ↑(stabilizer G s) * s → x✝ ∈ s

tactic: rintro ⟨a, ha, b, hb, rfl⟩
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Set G
x✝ : G
⊢ x✝ ∈ ↑(stabilizer G s) * s → x✝ ∈ s
state_after: case h.intro.intro.intro.intro
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Set G
a : G
ha : a ∈ ↑(stabilizer G s)
b : G
hb : b ∈ s
⊢ (fun x x_1 => x * x_1) a b ∈ s

tactic: rw [← mem_stabilizer_iff.1 ha]
state_before: case h.intro.intro.intro.intro
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Set G
a : G
ha : a ∈ ↑(stabilizer G s)
b : G
hb : b ∈ s
⊢ (fun x x_1 => x * x_1) a b ∈ s
state_after: case h.intro.intro.intro.intro
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Set G
a : G
ha : a ∈ ↑(stabilizer G s)
b : G
hb : b ∈ s
⊢ (fun x x_1 => x * x_1) a b ∈ a • s

tactic: exact smul_mem_smul_set hb
state_before: case h.intro.intro.intro.intro
G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Set G
a : G
ha : a ∈ ↑(stabilizer G s)
b : G
hb : b ∈ s
⊢ (fun x x_1 => x * x_1) a b ∈ a • s
state_after: no goals
Theorem: Nat.minFac_lemma
File: Mathlib/Data/Nat/Prime.lean

tactic: decide
state_before: n✝ n k : ℕ
h : ¬n < k * k
⊢ 0 < 2
state_after: no goals
Theorem: Complex.frontier_setOf_im_lt
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Iio] using frontier_preimage_im (Iio a)
state_before: a : ℝ
⊢ frontier {z | z.im < a} = {z | z.im = a}
state_after: no goals
Theorem: Complex.one_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: rw [cpow_def]
state_before: x : ℂ
⊢ 1 ^ x = 1
state_after: x : ℂ
⊢ (if 1 = 0 then if x = 0 then 1 else 0 else cexp (log 1 * x)) = 1

tactic: split_ifs <;> simp_all [one_ne_zero]
state_before: x : ℂ
⊢ (if 1 = 0 then if x = 0 then 1 else 0 else cexp (log 1 * x)) = 1
state_after: no goals
Theorem: CantorScheme.map_mem
File: Mathlib/Topology/MetricSpace/CantorScheme.lean

tactic: have := x.property.some_mem
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
⊢ (inducedMap A).snd x ∈ A (res (↑x) n)
state_after: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : Set.Nonempty.some ⋯ ∈ ⋂ n, A (res (↑x) n)
⊢ (inducedMap A).snd x ∈ A (res (↑x) n)

tactic: rw [mem_iInter] at this
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : Set.Nonempty.some ⋯ ∈ ⋂ n, A (res (↑x) n)
⊢ (inducedMap A).snd x ∈ A (res (↑x) n)
state_after: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : ∀ (i : ℕ), Set.Nonempty.some ⋯ ∈ A (res (↑x) i)
⊢ (inducedMap A).snd x ∈ A (res (↑x) n)

tactic: exact this n
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : ∀ (i : ℕ), Set.Nonempty.some ⋯ ∈ A (res (↑x) i)
⊢ (inducedMap A).snd x ∈ A (res (↑x) n)
state_after: no goals
Theorem: DFinsupp.Lex.wellFounded
File: Mathlib/Data/DFinsupp/WellFounded.lean

tactic: classical exact Lex.acc hbot hs x fun i _ => hr.apply i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0
hs : ∀ (i : ι), WellFounded (s i)
hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1)
x : Π₀ (i : ι), α i
⊢ Acc (DFinsupp.Lex r s) x
state_after: no goals

tactic: exact Lex.acc hbot hs x fun i _ => hr.apply i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
hbot : ∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬s i a 0
hs : ∀ (i : ι), WellFounded (s i)
hr : WellFounded (rᶜ ⊓ fun x x_1 => x ≠ x_1)
x : Π₀ (i : ι), α i
⊢ Acc (DFinsupp.Lex r s) x
state_after: no goals
Theorem: Filter.map_map₂
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [← map_prod_eq_map₂, ← map_prod_eq_map₂, map_map]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
n : γ → δ
⊢ map n (map₂ m f g) = map₂ (fun a b => n (m a b)) f g
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
n : γ → δ
⊢ map (n ∘ fun p => m p.1 p.2) (f ×ˢ g) = map (fun p => n (m p.1 p.2)) (f ×ˢ g)

tactic: rfl
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
n : γ → δ
⊢ map (n ∘ fun p => m p.1 p.2) (f ×ˢ g) = map (fun p => n (m p.1 p.2)) (f ×ˢ g)
state_after: no goals
Theorem: Set.surjective_iff_surjOn_univ
File: Mathlib/Data/Set/Function.lean

tactic: simp [Surjective, SurjOn, subset_def]
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 : β
⊢ Surjective f ↔ SurjOn f univ univ
state_after: no goals