1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: mem_closure_isSwap'
File: Mathlib/GroupTheory/Perm/ClosureSwap.lean

tactic: refine (mem_closure_isSwap fun _ ↦ id).trans
  (and_iff_left fun x ↦ ⟨⟨swap x (f x), ?_⟩, swap_apply_left x (f x)⟩)
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
⊢ f ∈ closure {σ | σ.IsSwap} ↔ (fixedBy α f)ᶜ.Finite
state_after: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y

tactic: by_cases h : x = f x
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y
state_after: case pos
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : x = f x
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y

case neg
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : ¬x = f x
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y

tactic: rw [← h, swap_self]
state_before: case pos
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : x = f x
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y
state_after: case pos
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : x = f x
⊢ Equiv.refl α ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y

tactic: apply Subgroup.one_mem
state_before: case pos
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : x = f x
⊢ Equiv.refl α ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y
state_after: no goals

tactic: exact subset_closure ⟨x, f x, h, rfl⟩
state_before: case neg
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : DecidableEq α
f : Equiv.Perm α
x : α
h : ¬x = f x
⊢ swap x (f x) ∈ closure fun x => ∃ x_1 y, x_1 ≠ y ∧ x = swap x_1 y
state_after: no goals
Theorem: toIcoMod_eventuallyEq_toIocMod
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: rw [Ico_eq_locus_Ioc_eq_iUnion_Ioo]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen {x | (fun x => toIcoMod hp a x = toIocMod hp a x) x}
state_after: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen (⋃ z, Ioo (a + z • p) (a + p + z • p))

tactic: exact isOpen_iUnion fun i => isOpen_Ioo
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p : 𝕜
hp : 0 < p
a x : 𝕜
hx : ↑x ≠ ↑a
⊢ IsOpen (⋃ z, Ioo (a + z • p) (a + p + z • p))
state_after: no goals
Theorem: Filter.map_prod_map_coprod_le
File: Mathlib/Order/Filter/Prod.lean

tactic: intro s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
⊢ map (Prod.map m₁ m₂) (f₁.coprod f₂) ≤ (map m₁ f₁).coprod (map m₂ f₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ s ∈ (map m₁ f₁).coprod (map m₂ f₂) → s ∈ map (Prod.map m₁ m₂) (f₁.coprod f₂)

tactic: simp only [mem_map, mem_coprod_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ s ∈ (map m₁ f₁).coprod (map m₂ f₂) → s ∈ map (Prod.map m₁ m₂) (f₁.coprod f₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ ((∃ t₁, m₁ ⁻¹' t₁ ∈ f₁ ∧ Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂, m₂ ⁻¹' t₂ ∈ f₂ ∧ Prod.snd ⁻¹' t₂ ⊆ s) →
    (∃ t₁ ∈ f₁, Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂ ∈ f₂, Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s

tactic: rintro ⟨⟨u₁, hu₁, h₁⟩, u₂, hu₂, h₂⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ ((∃ t₁, m₁ ⁻¹' t₁ ∈ f₁ ∧ Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂, m₂ ⁻¹' t₂ ∈ f₂ ∧ Prod.snd ⁻¹' t₂ ⊆ s) →
    (∃ t₁ ∈ f₁, Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂ ∈ f₂, Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s
state_after: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
u₁ : Set β₁
hu₁ : m₁ ⁻¹' u₁ ∈ f₁
h₁ : Prod.fst ⁻¹' u₁ ⊆ s
u₂ : Set β₂
hu₂ : m₂ ⁻¹' u₂ ∈ f₂
h₂ : Prod.snd ⁻¹' u₂ ⊆ s
⊢ (∃ t₁ ∈ f₁, Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂ ∈ f₂, Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s

tactic: refine ⟨⟨m₁ ⁻¹' u₁, hu₁, fun _ hx => h₁ ?_⟩, ⟨m₂ ⁻¹' u₂, hu₂, fun _ hx => h₂ ?_⟩⟩ <;> convert hx
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
u₁ : Set β₁
hu₁ : m₁ ⁻¹' u₁ ∈ f₁
h₁ : Prod.fst ⁻¹' u₁ ⊆ s
u₂ : Set β₂
hu₂ : m₂ ⁻¹' u₂ ∈ f₂
h₂ : Prod.snd ⁻¹' u₂ ⊆ s
⊢ (∃ t₁ ∈ f₁, Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂ ∈ f₂, Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s
state_after: no goals
Theorem: List.Ico.filter_lt
File: Mathlib/Data/List/Intervals.lean

tactic: rcases le_total m l with hml | hlm
state_before: n m l : ℕ
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)
state_after: case inl
n m l : ℕ
hml : m ≤ l
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)

case inr
n m l : ℕ
hlm : l ≤ m
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)

tactic: rw [min_eq_left hml, filter_lt_of_top_le hml]
state_before: case inl
n m l : ℕ
hml : m ≤ l
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)
state_after: no goals

tactic: rw [min_eq_right hlm, filter_lt_of_ge hlm]
state_before: case inr
n m l : ℕ
hlm : l ≤ m
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)
state_after: no goals
Theorem: Complementeds.isCompl_coe
File: Mathlib/Order/Disjoint.lean

tactic: simp_rw [isCompl_iff, disjoint_coe, codisjoint_coe]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b : Complementeds α
⊢ IsCompl ↑a ↑b ↔ IsCompl a b
state_after: no goals
Theorem: GaussianInt.norm_mod_lt
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

tactic: rwa [Ne, ← toComplex_zero, toComplex_inj]
state_before: x y : ℤ[i]
hy : y ≠ 0
⊢ toComplex y ≠ 0
state_after: no goals

tactic: simp [mod_def]
state_before: x y : ℤ[i]
hy : y ≠ 0
this : toComplex y ≠ 0
⊢ ↑(norm (x % y)) = normSq (toComplex x - toComplex y * toComplex (x / y))
state_after: no goals

tactic: rw [← normSq_mul, mul_sub, mul_div_cancel₀ _ this]
state_before: x y : ℤ[i]
hy : y ≠ 0
this : toComplex y ≠ 0
⊢ normSq (toComplex x - toComplex y * toComplex (x / y)) =
    normSq (toComplex y) * normSq (toComplex x / toComplex y - toComplex (x / y))
state_after: no goals

tactic: simp
state_before: x y : ℤ[i]
hy : y ≠ 0
this : toComplex y ≠ 0
⊢ normSq (toComplex y) * 1 = ↑(norm y)
state_after: no goals
Theorem: QuaternionAlgebra.Basis.lift_smul
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp [lift, mul_smul, ← Algebra.smul_def]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
r : R
x : ℍ[R,c₁,c₂]
⊢ q.lift (r • x) = r • q.lift x
state_after: no goals
Theorem: WeierstrassCurve.Affine.CoordinateRing.map_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

tactic: rw [smul, _root_.map_mul, map_mk, map_C, smul]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (map W f) (x • y) = Polynomial.map f x • (map W f) y
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (mk (WeierstrassCurve.map W f)) (C ((mapRingHom f) x)) * (map W f) y =
    (mk (WeierstrassCurve.map W f).toAffine) (C (Polynomial.map f x)) * (map W f) y

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (mk (WeierstrassCurve.map W f)) (C ((mapRingHom f) x)) * (map W f) y =
    (mk (WeierstrassCurve.map W f).toAffine) (C (Polynomial.map f x)) * (map W f) y
state_after: no goals
Theorem: CategoryTheory.NatTrans.naturality_apply
File: Mathlib/CategoryTheory/ConcreteCategory/Basic.lean

tactic: simpa only [Functor.map_comp] using congr_fun ((forget D).congr_map (φ.naturality f)) x
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
inst✝ : ConcreteCategory D
F G : C ⥤ D
φ : F ⟶ G
X Y : C
f : X ⟶ Y
x : (forget D).obj (F.obj X)
⊢ (φ.app Y) ((F.map f) x) = (G.map f) ((φ.app X) x)
state_after: no goals
Theorem: Complex.interior_setOf_le_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [interior_Ici] using interior_preimage_re (Ici a)
state_before: a : ℝ
⊢ interior {z | a ≤ z.re} = {z | a < z.re}
state_after: no goals
Theorem: Nat.gcd_mul_right_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [gcd_comm, gcd_mul_right_add_right, gcd_comm]
state_before: m n k : ℕ
⊢ (k * n + m).gcd n = m.gcd n
state_after: no goals
Theorem: SimpleGraph.two_mul_card_edgeFinset
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

tactic: rw [← dart_card_eq_twice_card_edges, ← card_univ]
state_before: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ 2 * G.edgeFinset.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card
state_after: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ univ.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card

tactic: refine card_bij' (fun d _ ↦ (d.fst, d.snd)) (fun xy h ↦ ⟨xy, (mem_filter.1 h).2⟩) ?_ ?_ ?_ ?_
  <;> simp
state_before: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ univ.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card
state_after: no goals
Theorem: Polynomial.natDegree_sum_le_of_forall_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
n : ℕ
f : ι → S[X]
h : ∀ i ∈ s, (f i).natDegree ≤ n
⊢ 0 ≤ n ∧ ∀ x ∈ s, (natDegree ∘ f) x ≤ n
state_after: no goals
Theorem: MeasurableSet.biInter
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

tactic: rw [compl_iInter₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋂ b ∈ s, f b)ᶜ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋃ i ∈ s, (f i)ᶜ)

tactic: exact .biUnion hs fun b hb => (h b hb).compl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋃ i ∈ s, (f i)ᶜ)
state_after: no goals
Theorem: SetTheory.Game.bddBelow_range_of_small
File: Mathlib/SetTheory/Game/Basic.lean

tactic: obtain ⟨x, hx⟩ := PGame.bddBelow_range_of_small (Quotient.out ∘ f)
state_before: ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → Game
⊢ BddBelow (Set.range f)
state_after: case intro
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → Game
x : PGame
hx : x ∈ lowerBounds (Set.range (Quotient.out ∘ f))
⊢ BddBelow (Set.range f)

tactic: refine ⟨⟦x⟧, Set.forall_mem_range.2 fun i ↦ ?_⟩
state_before: case intro
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → Game
x : PGame
hx : x ∈ lowerBounds (Set.range (Quotient.out ∘ f))
⊢ BddBelow (Set.range f)
state_after: case intro
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → Game
x : PGame
hx : x ∈ lowerBounds (Set.range (Quotient.out ∘ f))
i : ι
⊢ ⟦x⟧ ≤ f i

tactic: simpa [PGame.le_iff_game_le] using hx $ Set.mem_range_self i
state_before: case intro
ι : Type u_1
inst✝ : Small.{u, u_1} ι
f : ι → Game
x : PGame
hx : x ∈ lowerBounds (Set.range (Quotient.out ∘ f))
i : ι
⊢ ⟦x⟧ ≤ f i
state_after: no goals
Theorem: IsUnramifiedAtInfinitePlaces.card_infinitePlace
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [InfinitePlace.card_eq_card_isUnramifiedIn (k := k) (K := K), Finset.filter_true_of_mem,
  Finset.card_univ, Finset.card_eq_zero.mpr, zero_mul, add_zero]
state_before: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ Fintype.card (InfinitePlace K) = Fintype.card (InfinitePlace k) * finrank k K
state_after: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ Finset.univᶜ = ∅

k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ ∀ x ∈ Finset.univ, InfinitePlace.IsUnramifiedIn K x

tactic: simp only [Finset.mem_univ, forall_true_left, Finset.filter_eq_empty_iff]
state_before: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ ∀ x ∈ Finset.univ, InfinitePlace.IsUnramifiedIn K x
state_after: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ ∀ (x : InfinitePlace k), InfinitePlace.IsUnramifiedIn K x

tactic: exact InfinitePlace.isUnramifiedIn K
state_before: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ ∀ (x : InfinitePlace k), InfinitePlace.IsUnramifiedIn K x
state_after: no goals

tactic: exact Finset.compl_univ
state_before: k : Type u_1
inst✝¹⁰ : Field k
K : Type u_2
inst✝⁹ : Field K
F : Type u_3
inst✝⁸ : Field F
inst✝⁷ : Algebra k K
inst✝⁶ : Algebra k F
inst✝⁵ : Algebra K F
inst✝⁴ : IsScalarTower k K F
inst✝³ : NumberField k
inst✝² : NumberField K
inst✝¹ : IsGalois k K
inst✝ : IsUnramifiedAtInfinitePlaces k K
⊢ Finset.univᶜ = ∅
state_after: no goals
Theorem: Polynomial.Chebyshev.map_U
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: induction n using Polynomial.Chebyshev.induct with
| zero => simp
| one => simp
| add_two n ih1 ih2 =>
  simp_rw [U_add_two, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
    ih2];
| neg_add_one n ih1 ih2 =>
  simp_rw [U_sub_one, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
    ih2];
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℤ
⊢ map f (U R n) = U S n
state_after: no goals

tactic: simp
state_before: case zero
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 0) = U S 0
state_after: no goals

tactic: simp
state_before: case one
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
⊢ map f (U R 1) = U S 1
state_after: no goals

tactic: simp_rw [U_add_two, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
  ih2]
state_before: case add_two
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
ih1 : map f (U R (↑n + 1)) = U S (↑n + 1)
ih2 : map f (U R ↑n) = U S ↑n
⊢ map f (U R (↑n + 2)) = U S (↑n + 2)
state_after: no goals

tactic: simp_rw [U_sub_one, Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_ofNat, map_X, ih1,
  ih2]
state_before: case neg_add_one
R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
n : ℕ
ih1 : map f (U R (-↑n)) = U S (-↑n)
ih2 : map f (U R (-↑n + 1)) = U S (-↑n + 1)
⊢ map f (U R (-↑n - 1)) = U S (-↑n - 1)
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.neg_le_neg
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro j hj₁
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
⊢ (-w).restrict i ≤ (-v).restrict i
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑((-w).restrict i) j ≤ ↑((-v).restrict i) j

tactic: rw [restrict_apply _ hi hj₁, restrict_apply _ hi hj₁, neg_apply, neg_apply]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑((-w).restrict i) j ≤ ↑((-v).restrict i) j
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ -↑w (j ∩ i) ≤ -↑v (j ∩ i)

tactic: refine neg_le_neg ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ -↑w (j ∩ i) ≤ -↑v (j ∩ i)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑v (j ∩ i) ≤ ↑w (j ∩ i)

tactic: rw [← restrict_apply _ hi hj₁, ← restrict_apply _ hi hj₁]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑v (j ∩ i) ≤ ↑w (j ∩ i)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑(v.restrict i) j ≤ ↑(w.restrict i) j

tactic: exact h j hj₁
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : OrderedAddCommGroup M
inst✝ : TopologicalAddGroup M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
h : v.restrict i ≤ w.restrict i
j : Set α
hj₁ : MeasurableSet j
⊢ ↑(v.restrict i) j ≤ ↑(w.restrict i) j
state_after: no goals
Theorem: ENNReal.essSup_liminf_le
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp_rw [essSup]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
ι : Type u_3
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → ℝ≥0∞
⊢ essSup (fun x => liminf (fun n => f n x) atTop) μ ≤ liminf (fun n => essSup (fun x => f n x) μ) atTop
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
ι : Type u_3
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → ℝ≥0∞
⊢ limsup (fun x => liminf (fun n => f n x) atTop) (ae μ) ≤ liminf (fun n => limsup (fun x => f n x) (ae μ)) atTop

tactic: exact ENNReal.limsup_liminf_le_liminf_limsup fun a b => f b a
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
ι : Type u_3
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → ℝ≥0∞
⊢ limsup (fun x => liminf (fun n => f n x) atTop) (ae μ) ≤ liminf (fun n => limsup (fun x => f n x) (ae μ)) atTop
state_after: no goals
Theorem: MeasurableEmbedding.ae_map_iff
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: simp only [ae_iff, hf.map_apply, preimage_setOf_eq]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
p : β → Prop
μ : Measure α
⊢ (∀ᵐ (x : β) ∂Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x)
state_after: no goals
Theorem: MeasureTheory.integral_eq
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp [integral, hE, hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : Integrable f μ
⊢ ∫ (a : α), f a ∂μ = L1.integral (Integrable.toL1 f hf)
state_after: no goals
Theorem: completeSpace_coe_iff_isComplete
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [Subtype.range_coe]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set α
⊢ IsComplete (range Subtype.val) ↔ IsComplete s
state_after: no goals
Theorem: mul_smul_one
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [← smul_eq_mul, ← smul_comm, smul_eq_mul, mul_one]
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
N : Type u_11
inst✝² : MulOneClass N
inst✝¹ : SMul M N
inst✝ : SMulCommClass M N N
x : M
y : N
⊢ y * x • 1 = x • y
state_after: no goals