1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.lt_mul_div_succ
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.mul_comm, ← Nat.div_lt_iff_lt_mul' hb]
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a < b * (a / b + 1)
state_after: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a / b < a / b + 1

tactic: exact lt_succ_self _
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a / b < a / b + 1
state_after: no goals
Theorem: singleton_div_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [singleton_div_closedBall, div_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / closedBall 1 δ = closedBall x δ
state_after: no goals
Theorem: MeasureTheory.measure_union_add_inter₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [← measure_inter_add_diff₀ (s ∪ t) ht, union_inter_cancel_right, union_diff_right, ←
  measure_inter_add_diff₀ s ht, add_comm, ← add_assoc, add_right_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
⊢ μ (s ∪ t) + μ (s ∩ t) = μ s + μ t
state_after: no goals
Theorem: continuousAt_prod_of_discrete_left
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp_rw [← continuousWithinAt_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
x : α × β
⊢ ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x.1, x_1)) x.2
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x.1, x_1)) univ x.2

tactic: exact continuousWithinAt_prod_of_discrete_left
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x.1, x_1)) univ x.2
state_after: no goals
Theorem: Batteries.RBNode.All.ins
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: induction t <;> unfold ins <;> try simp [*]
state_before: α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
t : RBNode α
h₁ : p x
h₂ : All p t
⊢ All p (ins cmp x t)
state_after: case node
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : All p l✝ → All p (ins cmp x l✝)
r_ih✝ : All p r✝ → All p (ins cmp x r✝)
h₂ : All p (node c✝ l✝ v✝ r✝)
⊢ All p
    (match node c✝ l✝ v✝ r✝ with
    | nil => node red nil x nil
    | node red a y b =>
      match cmp x y with
      | Ordering.lt => node red (ins cmp x a) y b
      | Ordering.gt => node red a y (ins cmp x b)
      | Ordering.eq => node red a x b
    | node black a y b =>
      match cmp x y with
      | Ordering.lt => (ins cmp x a).balance1 y b
      | Ordering.gt => a.balance2 y (ins cmp x b)
      | Ordering.eq => node black a x b)

tactic: split <;> cases ‹_=_› <;> split <;> simp at h₂ <;> simp [*]
state_before: case node
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : All p l✝ → All p (ins cmp x l✝)
r_ih✝ : All p r✝ → All p (ins cmp x r✝)
h₂ : All p (node c✝ l✝ v✝ r✝)
⊢ All p
    (match node c✝ l✝ v✝ r✝ with
    | nil => node red nil x nil
    | node red a y b =>
      match cmp x y with
      | Ordering.lt => node red (ins cmp x a) y b
      | Ordering.gt => node red a y (ins cmp x b)
      | Ordering.eq => node red a x b
    | node black a y b =>
      match cmp x y with
      | Ordering.lt => (ins cmp x a).balance1 y b
      | Ordering.gt => a.balance2 y (ins cmp x b)
      | Ordering.eq => node black a x b)
state_after: no goals

tactic: simp [*]
state_before: case nil
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
h₂ : All p nil
⊢ All p (node red nil x nil)
state_after: no goals
Theorem: MvPolynomial.supported_empty
File: Mathlib/Algebra/MvPolynomial/Supported.lean

tactic: simp [supported_eq_adjoin_X]
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
⊢ supported R ∅ = ⊥
state_after: no goals
Theorem: Seminorm.isBounded_const
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: simp only [IsBounded, forall_const]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕝 : Type u_3
𝕝₂ : Type u_4
E : Type u_5
F : Type u_6
G : Type u_7
ι : Type u_8
ι'✝ : Type u_9
inst✝⁷ : NormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : NormedField 𝕜₂
inst✝³ : AddCommGroup F
inst✝² : Module 𝕜₂ F
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝¹ : RingHomIsometric σ₁₂
ι' : Type u_10
inst✝ : Nonempty ι'
p : ι → Seminorm 𝕜 E
q : Seminorm 𝕜₂ F
f : E →ₛₗ[σ₁₂] F
⊢ IsBounded p (fun x => q) f ↔ ∃ s C, q.comp f ≤ C • s.sup p
state_after: no goals
Theorem: Filter.comap_inf_principal_range
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g ⊓ 𝓟 (range m)) = comap m g
state_after: no goals
Theorem: AddChar.starComp_eq_inv
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

tactic: ext1 a
state_before: R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
⊢ (↑(starRingEnd ℂ)).compAddChar φ = φ⁻¹
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ ((↑(starRingEnd ℂ)).compAddChar φ) a = φ⁻¹ a

tactic: simp only [RingHom.toMonoidHom_eq_coe, MonoidHom.coe_compAddChar, MonoidHom.coe_coe,
  Function.comp_apply, inv_apply']
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ ((↑(starRingEnd ℂ)).compAddChar φ) a = φ⁻¹ a
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹

tactic: have H := Complex.norm_eq_one_of_mem_rootsOfUnity <| φ.val_mem_rootsOfUnity a hR
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
H : ‖↑⋯.unit‖ = 1
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹

tactic: exact (Complex.inv_eq_conj H).symm
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
H : ‖↑⋯.unit‖ = 1
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
state_after: no goals
Theorem: SimpleGraph.Subgraph.degree_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [← card_neighborSet_eq_degree]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ G.degree v
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ Fintype.card ↑(G.neighborSet v)

tactic: exact Set.card_le_card (G'.neighborSet_subset v)
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v : V
inst✝¹ : Fintype ↑(G'.neighborSet v)
inst✝ : Fintype ↑(G.neighborSet v)
⊢ G'.degree v ≤ Fintype.card ↑(G.neighborSet v)
state_after: no goals
Theorem: ContinuousLinearMap.smulRight_comp
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝²¹ : Semiring R₁
inst✝²⁰ : Semiring R₂
inst✝¹⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁸ : TopologicalSpace M₁
inst✝¹⁷ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁶ : TopologicalSpace M'₁
inst✝¹⁵ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁴ : TopologicalSpace M₂
inst✝¹³ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹² : TopologicalSpace M₃
inst✝¹¹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝¹⁰ : TopologicalSpace M₄
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R₁ M₁
inst✝⁷ : Module R₁ M'₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type u_9
inst✝³ : Module R₁ M₂
inst✝² : TopologicalSpace R₁
inst✝¹ : ContinuousSMul R₁ M₂
inst✝ : ContinuousMul R₁
x : M₂
c : R₁
⊢ (smulRight 1 x).comp (smulRight 1 c) = smulRight 1 (c • x)
state_after: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝²¹ : Semiring R₁
inst✝²⁰ : Semiring R₂
inst✝¹⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁸ : TopologicalSpace M₁
inst✝¹⁷ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁶ : TopologicalSpace M'₁
inst✝¹⁵ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁴ : TopologicalSpace M₂
inst✝¹³ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹² : TopologicalSpace M₃
inst✝¹¹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝¹⁰ : TopologicalSpace M₄
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R₁ M₁
inst✝⁷ : Module R₁ M'₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type u_9
inst✝³ : Module R₁ M₂
inst✝² : TopologicalSpace R₁
inst✝¹ : ContinuousSMul R₁ M₂
inst✝ : ContinuousMul R₁
x : M₂
c : R₁
⊢ ((smulRight 1 x).comp (smulRight 1 c)) 1 = (smulRight 1 (c • x)) 1

tactic: simp [mul_smul]
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝²¹ : Semiring R₁
inst✝²⁰ : Semiring R₂
inst✝¹⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁸ : TopologicalSpace M₁
inst✝¹⁷ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁶ : TopologicalSpace M'₁
inst✝¹⁵ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁴ : TopologicalSpace M₂
inst✝¹³ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹² : TopologicalSpace M₃
inst✝¹¹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝¹⁰ : TopologicalSpace M₄
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R₁ M₁
inst✝⁷ : Module R₁ M'₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type u_9
inst✝³ : Module R₁ M₂
inst✝² : TopologicalSpace R₁
inst✝¹ : ContinuousSMul R₁ M₂
inst✝ : ContinuousMul R₁
x : M₂
c : R₁
⊢ ((smulRight 1 x).comp (smulRight 1 c)) 1 = (smulRight 1 (c • x)) 1
state_after: no goals
Theorem: LinearMap.eqLocus_eq_top
File: Mathlib/Algebra/Module/Submodule/EqLocus.lean

tactic: simp [SetLike.ext_iff, DFunLike.ext_iff]
state_before: R : Type u_1
R₂ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_5
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f g : F
⊢ eqLocus f g = ⊤ ↔ f = g
state_after: no goals
Theorem: Mathlib.Tactic.Ring.natCast_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ : ℕ
b₁ : R
a₃ : ℕ
b₃ : R
a₂ : ℕ
x✝¹ : ↑a₁ = b₁
x✝ : ↑a₃ = b₃
⊢ ↑(a₁ ^ a₂ * a₃) = b₁ ^ a₂ * b₃
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ a₃ a₂ : ℕ
⊢ ↑(a₁ ^ a₂ * a₃) = ↑a₁ ^ a₂ * ↑a₃

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ a₃ a₂ : ℕ
⊢ ↑(a₁ ^ a₂ * a₃) = ↑a₁ ^ a₂ * ↑a₃
state_after: no goals
Theorem: Subgroup.le_normalizer
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [H.mul_mem_cancel_right (H.inv_mem xH), H.mul_mem_cancel_left xH]
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
H K : Subgroup G
x : G
xH : x ∈ H
n : G
⊢ n ∈ H ↔ x * n * x⁻¹ ∈ H
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Hom.inv_invApp
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

tactic: exact (Set.preimage_image_eq U.1 H.base_open.inj).symm
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ ↑U = ↑(f ⁻¹ᵁ f ''ᵁ U)
state_after: no goals

tactic: rw [eqToHom_op]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Opens ↑↑X.toPresheafedSpace
⊢ f.val.c.app { unop := (PresheafedSpace.IsOpenImmersion.opensFunctor f.val).obj U } ≫ X.presheaf.map (eqToHom ⋯) =
    f.app (f ''ᵁ U) ≫ X.presheaf.map (eqToHom ⋯).op
state_after: no goals
Theorem: Finset.le_prod_of_submultiplicative_on_pred
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: rcases eq_empty_or_nonempty s with (rfl | hs_nonempty)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
p : M → Prop
h_one : f 1 = 1
h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y
hp_mul : ∀ (x y : M), p x → p y → p (x * y)
g : ι → M
s : Finset ι
hs : ∀ i ∈ s, p (g i)
⊢ f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
p : M → Prop
h_one : f 1 = 1
h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y
hp_mul : ∀ (x y : M), p x → p y → p (x * y)
g : ι → M
hs : ∀ i ∈ ∅, p (g i)
⊢ f (∏ i ∈ ∅, g i) ≤ ∏ i ∈ ∅, f (g i)

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
p : M → Prop
h_one : f 1 = 1
h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y
hp_mul : ∀ (x y : M), p x → p y → p (x * y)
g : ι → M
s : Finset ι
hs : ∀ i ∈ s, p (g i)
hs_nonempty : s.Nonempty
⊢ f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)

tactic: simp [h_one]
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
p : M → Prop
h_one : f 1 = 1
h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y
hp_mul : ∀ (x y : M), p x → p y → p (x * y)
g : ι → M
hs : ∀ i ∈ ∅, p (g i)
⊢ f (∏ i ∈ ∅, g i) ≤ ∏ i ∈ ∅, f (g i)
state_after: no goals

tactic: exact le_prod_nonempty_of_submultiplicative_on_pred f p h_mul hp_mul g s hs_nonempty hs
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
p : M → Prop
h_one : f 1 = 1
h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y
hp_mul : ∀ (x y : M), p x → p y → p (x * y)
g : ι → M
s : Finset ι
hs : ∀ i ∈ s, p (g i)
hs_nonempty : s.Nonempty
⊢ f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)
state_after: no goals
Theorem: IntermediateField.finInsepDegree_bot'
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: simpa only [Cardinal.toNat_lift] using congr_arg Cardinal.toNat (lift_insepDegree_bot' F E K)
state_before: F : Type u
E : Type v
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
K : Type w
inst✝³ : Field K
inst✝² : Algebra F K
inst✝¹ : Algebra E K
inst✝ : IsScalarTower F E K
⊢ finInsepDegree F ↥⊥ = finInsepDegree F E
state_after: no goals
Theorem: Real.fourierIntegral_comp_linearIsometry
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp only [fourierIntegral_eq, ← A.inner_map_map, Function.comp_apply,
  ← MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding]
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
A : W ≃ₗᵢ[ℝ] V
f : V → E
w : W
⊢ 𝓕 (f ∘ ⇑A) w = 𝓕 f (A w)
state_after: no goals
Theorem: dense_sInter_of_isOpen
File: Mathlib/Topology/Baire/Lemmas.lean

tactic: rcases S.eq_empty_or_nonempty with h | h
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
⊢ Dense (⋂₀ S)
state_after: case inl
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S = ∅
⊢ Dense (⋂₀ S)

case inr
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S.Nonempty
⊢ Dense (⋂₀ S)

tactic: simp [h]
state_before: case inl
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S = ∅
⊢ Dense (⋂₀ S)
state_after: no goals

tactic: rcases hS.exists_eq_range h with ⟨f, rfl⟩
state_before: case inr
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S.Nonempty
⊢ Dense (⋂₀ S)
state_after: case inr.intro
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
f : ℕ → Set X
ho : ∀ s ∈ range f, IsOpen s
hS : (range f).Countable
hd : ∀ s ∈ range f, Dense s
h : (range f).Nonempty
⊢ Dense (⋂₀ range f)

tactic: exact dense_iInter_of_isOpen_nat (forall_mem_range.1 ho) (forall_mem_range.1 hd)
state_before: case inr.intro
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
f : ℕ → Set X
ho : ∀ s ∈ range f, IsOpen s
hS : (range f).Countable
hd : ∀ s ∈ range f, Dense s
h : (range f).Nonempty
⊢ Dense (⋂₀ range f)
state_after: no goals
Theorem: CategoryTheory.Limits.pullback.mapDesc_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
W X✝ Y✝ Z X Y S T S' : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
i' : S ⟶ S'
inst✝³ : HasPullback f g
inst✝² : HasPullback (f ≫ i) (g ≫ i)
inst✝¹ : HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')
inst✝ : HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')
⊢ mapDesc f g (i ≫ i') = mapDesc f g i ≫ mapDesc (f ≫ i) (g ≫ i) i' ≫ (congrHom ⋯ ⋯).hom
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.IsNormal.vertexSubgroup
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: rw [mul_assoc]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * x * y⁻¹ ∈ S.vertexSubgroup cS
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * (x * y⁻¹) ∈ S.vertexSubgroup cS

tactic: exact Sn.conj' y hx
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * (x * y⁻¹) ∈ S.vertexSubgroup cS
state_after: no goals
Theorem: WithTop.LinearOrderedAddCommGroup.sub_eq_top_iff
File: Mathlib/Algebra/Order/Group/WithTop.lean

tactic: cases a <;> cases b <;> simp [← coe_sub]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d : α
a b : WithTop α
⊢ a - b = ⊤ ↔ a = ⊤ ∨ b = ⊤
state_after: no goals
Theorem: LSeriesSummable_of_bounded_of_one_lt_re
File: Mathlib/NumberTheory/LSeries/Basic.lean

tactic: refine LSeriesSummable_of_le_const_mul_rpow hs ⟨m, fun n hn ↦ ?_⟩
state_before: f : ℕ → ℂ
m : ℝ
h : ∀ (n : ℕ), n ≠ 0 → Complex.abs (f n) ≤ m
s : ℂ
hs : 1 < s.re
⊢ LSeriesSummable f s
state_after: f : ℕ → ℂ
m : ℝ
h : ∀ (n : ℕ), n ≠ 0 → Complex.abs (f n) ≤ m
s : ℂ
hs : 1 < s.re
n : ℕ
hn : n ≠ 0
⊢ ‖f n‖ ≤ m * ↑n ^ (1 - 1)

tactic: simp only [norm_eq_abs, sub_self, Real.rpow_zero, mul_one, h n hn]
state_before: f : ℕ → ℂ
m : ℝ
h : ∀ (n : ℕ), n ≠ 0 → Complex.abs (f n) ≤ m
s : ℂ
hs : 1 < s.re
n : ℕ
hn : n ≠ 0
⊢ ‖f n‖ ≤ m * ↑n ^ (1 - 1)
state_after: no goals
Theorem: List.sum_le_foldr_max
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

tactic: induction' l with hd tl IH
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
l : List M
⊢ f l.sum ≤ foldr max 0 (map f l)
state_after: case nil
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
⊢ f [].sum ≤ foldr max 0 (map f [])

case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr max 0 (map f tl)
⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))

tactic: simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
state_before: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr max 0 (map f tl)
⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))
state_after: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr (fun x y => max (f x) y) 0 tl
⊢ f (hd + tl.sum) ≤ max (f hd) (foldr (fun x y => max (f x) y) 0 tl)

tactic: exact (hadd _ _).trans (max_le_max le_rfl IH)
state_before: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr (fun x y => max (f x) y) 0 tl
⊢ f (hd + tl.sum) ≤ max (f hd) (foldr (fun x y => max (f x) y) 0 tl)
state_after: no goals

tactic: simpa using h0
state_before: case nil
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
⊢ f [].sum ≤ foldr max 0 (map f [])
state_after: no goals
Theorem: Filter.pi_pure
File: Mathlib/Order/Filter/Pi.lean

tactic: simp only [← principal_singleton, pi_principal, univ_pi_singleton]
state_before: ι : Type u_1
α : ι → Type u_2
f✝ f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : Finite ι
f : (i : ι) → α i
⊢ (pi fun x => pure (f x)) = pure f
state_after: no goals