1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsCompact.nhdsSet_inf_eq_biSup
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simp_rw [this, ← comap_iSup, hK.nhdsSet_prod_eq_biSup]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t K : Set X
hK : IsCompact K
l : Filter X
this : ∀ (f : Filter X), f ⊓ l = comap (fun x => (x, x)) (f ×ˢ l)
⊢ 𝓝ˢ K ⊓ l = ⨆ x ∈ K, 𝓝 x ⊓ l
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.integral_eq_tsum
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rfl
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹² : Group G
inst✝¹¹ : Group H
inst✝¹⁰ : MulAction G α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MulAction H β
inst✝⁷ : MeasurableSpace β
inst✝⁶ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : Countable G
ν : Measure α
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : IsFundamentalDomain G s μ
f : α → E
hf : Integrable f μ
⊢ μ ≪ μ
state_after: no goals
Theorem: MvPolynomial.funext_iff
File: Mathlib/Algebra/MvPolynomial/Funext.lean

tactic: rintro rfl
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : Infinite R
σ : Type u_2
p q : MvPolynomial σ R
⊢ p = q → ∀ (x : σ → R), (eval x) p = (eval x) q
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : Infinite R
σ : Type u_2
p : MvPolynomial σ R
⊢ ∀ (x : σ → R), (eval x) p = (eval x) p

tactic: simp only [forall_const, eq_self_iff_true]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : Infinite R
σ : Type u_2
p : MvPolynomial σ R
⊢ ∀ (x : σ → R), (eval x) p = (eval x) p
state_after: no goals
Theorem: PartENat.ofENat_toWithTop
File: Mathlib/Data/Nat/PartENat.lean

tactic: induction x using PartENat.casesOn <;> simp
state_before: x : PartENat
x✝ : Decidable x.Dom
⊢ ↑x.toWithTop = x
state_after: no goals
Theorem: Finset.Colex.mem_initSeg
File: Mathlib/Combinatorics/Colex.lean

tactic: simp [initSeg]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
⊢ t ∈ initSeg s ↔ s.card = t.card ∧ { ofColex := t } ≤ { ofColex := s }
state_after: no goals
Theorem: Set.pairwise_union_of_symmetric
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [hr.iff, and_self_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
⊢ (s.Pairwise r ∧ t.Pairwise r ∧ ∀ a ∈ s, ∀ b ∈ t, a ≠ b → r a b ∧ r b a) ↔
    s.Pairwise r ∧ t.Pairwise r ∧ ∀ a ∈ s, ∀ b ∈ t, a ≠ b → r a b
state_after: no goals
Theorem: Complex.angle_div_right_eq_angle_mul_left
File: Mathlib/Analysis/Complex/Angle.lean

tactic: rw [angle_comm, angle_div_left_eq_angle_mul_right, angle_comm]
state_before: a✝ x✝ y✝ a x y : ℂ
⊢ angle x (y / a) = angle (x * a) y
state_after: no goals
Theorem: FirstOrder.Language.Theory.isSatisfiable_onTheory_iff
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: classical
  refine ⟨isSatisfiable_of_isSatisfiable_onTheory φ, fun h' => ?_⟩
  haveI : Inhabited h'.some := Classical.inhabited_of_nonempty'
  exact Model.isSatisfiable (h'.some.defaultExpansion h)
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
⊢ (φ.onTheory T).IsSatisfiable ↔ T.IsSatisfiable
state_after: no goals

tactic: refine ⟨isSatisfiable_of_isSatisfiable_onTheory φ, fun h' => ?_⟩
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
⊢ (φ.onTheory T).IsSatisfiable ↔ T.IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
h' : T.IsSatisfiable
⊢ (φ.onTheory T).IsSatisfiable

tactic: haveI : Inhabited h'.some := Classical.inhabited_of_nonempty'
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
h' : T.IsSatisfiable
⊢ (φ.onTheory T).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
h' : T.IsSatisfiable
this : Inhabited ↑(Nonempty.some h')
⊢ (φ.onTheory T).IsSatisfiable

tactic: exact Model.isSatisfiable (h'.some.defaultExpansion h)
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
T' : L.Theory
L' : Language
φ : L →ᴸ L'
h : φ.Injective
h' : T.IsSatisfiable
this : Inhabited ↑(Nonempty.some h')
⊢ (φ.onTheory T).IsSatisfiable
state_after: no goals
Theorem: ZFSet.map_fval
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [Class.toSet_of_ZFSet, Class.coe_apply, mem_map]
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
⊢ Class.ToSet (fun x_1 => ↑(map f x) (x_1.pair z)) ↑y ↔ z = f y
state_after: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
⊢ (∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z) ↔ z = f y

tactic: exact
  ⟨fun ⟨w, _, pr⟩ => by
    let ⟨wy, fw⟩ := ZFSet.pair_injective pr
    rw [← fw, wy], fun e => by
    subst e
    exact ⟨_, h, rfl⟩⟩
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
⊢ (∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z) ↔ z = f y
state_after: no goals

tactic: let ⟨wy, fw⟩ := ZFSet.pair_injective pr
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
x✝ : ∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z
w : ZFSet
left✝ : w ∈ x
pr : w.pair (f w) = y.pair z
⊢ z = f y
state_after: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
x✝ : ∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z
w : ZFSet
left✝ : w ∈ x
pr : w.pair (f w) = y.pair z
wy : w = y
fw : f w = z
⊢ z = f y

tactic: rw [← fw, wy]
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
x✝ : ∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z
w : ZFSet
left✝ : w ∈ x
pr : w.pair (f w) = y.pair z
wy : w = y
fw : f w = z
⊢ z = f y
state_after: no goals

tactic: subst e
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
e : z = f y
⊢ ∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z
state_after: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
⊢ ∃ z ∈ x, z.pair (f z) = y.pair (f y)

tactic: exact ⟨_, h, rfl⟩
state_before: f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
⊢ ∃ z ∈ x, z.pair (f z) = y.pair (f y)
state_after: no goals
Theorem: Mathlib.Tactic.Ring.mul_add
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₁ c₁ b₂ c₂ d : R
x✝² : a * b₁ = c₁
x✝¹ : a * b₂ = c₂
x✝ : c₁ + 0 + c₂ = d
⊢ a * (b₁ + b₂) = d
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₁ b₂ : R
⊢ a * (b₁ + b₂) = a * b₁ + 0 + a * b₂

tactic: simp [_root_.mul_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₁ b₂ : R
⊢ a * (b₁ + b₂) = a * b₁ + 0 + a * b₂
state_after: no goals
Theorem: MeasureTheory.measure_union_add_inter'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [union_comm, inter_comm, measure_union_add_inter t hs, add_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ μ (s ∪ t) + μ (s ∩ t) = μ s + μ t
state_after: no goals
Theorem: CliffordAlgebra.contractRight_algebraMap_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: rw [← Algebra.smul_def, LinearMap.map_smul₂, Algebra.smul_def]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
b : CliffordAlgebra Q
⊢ (contractRight ((algebraMap R (CliffordAlgebra Q)) r * b)) d =
    (algebraMap R (CliffordAlgebra Q)) r * (contractRight b) d
state_after: no goals
Theorem: BoxIntegral.Box.mk'_eq_bot
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: rw [mk']
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ mk' l u = ⊥ ↔ ∃ i, u i ≤ l i
state_after: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) = ⊥ ↔ ∃ i, u i ≤ l i

tactic: split_ifs with h <;> simpa using h
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) = ⊥ ↔ ∃ i, u i ≤ l i
state_after: no goals
Theorem: Filter.disjoint_cocompact_right
File: Mathlib/Topology/Compactness/Compact.lean

tactic: simp_rw [hasBasis_cocompact.disjoint_iff_right, compl_compl]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
⊢ Disjoint f (cocompact X) ↔ ∃ K ∈ f, IsCompact K
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
⊢ (∃ i, IsCompact i ∧ i ∈ f) ↔ ∃ K ∈ f, IsCompact K

tactic: tauto
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
⊢ (∃ i, IsCompact i ∧ i ∈ f) ↔ ∃ K ∈ f, IsCompact K
state_after: no goals
Theorem: String.extract.go₁_zero_utf8Len
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa using go₂_append_left s [] 0 (utf8Len s) rfl
state_before: s : List Char
⊢ go₂ s { byteIdx := 0 } { byteIdx := utf8Len s } = s
state_after: no goals
Theorem: Set.piecewise_preimage
File: Mathlib/Data/Set/Function.lean

tactic: by_cases x ∈ s <;> simp [*, Set.ite]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
t : Set β
x : α
⊢ x ∈ s.piecewise f g ⁻¹' t ↔ x ∈ s.ite (f ⁻¹' t) (g ⁻¹' t)
state_after: no goals
Theorem: Multiset.cons_sigma
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [Multiset.sigma]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
σ : α → Type u_4
a : α
s : Multiset α
t : (a : α) → Multiset (σ a)
⊢ (a ::ₘ s).sigma t = map (Sigma.mk a) (t a) + s.sigma t
state_after: no goals
Theorem: uncountable_iff_isEmpty_embedding
File: Mathlib/Data/Countable/Basic.lean

tactic: rw [← not_countable_iff, countable_iff_nonempty_embedding, not_nonempty_iff]
state_before: α : Sort u
β : Sort v
⊢ Uncountable α ↔ IsEmpty (α ↪ ℕ)
state_after: no goals
Theorem: UniqueFactorizationMonoid.normalizedFactors_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [normalizedFactors, factors, dif_neg ane0]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (normalizedFactors a).prod ~ᵤ a
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (⇑normalize) (Classical.choose ⋯)).prod ~ᵤ a

tactic: refine Associated.trans ?_ (Classical.choose_spec (exists_prime_factors a ane0)).2
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (⇑normalize) (Classical.choose ⋯)).prod ~ᵤ a
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (⇑normalize) (Classical.choose ⋯)).prod ~ᵤ (Classical.choose ⋯).prod

tactic: rw [← Associates.mk_eq_mk_iff_associated, ← Associates.prod_mk, ← Associates.prod_mk,
  Multiset.map_map]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (⇑normalize) (Classical.choose ⋯)).prod ~ᵤ (Classical.choose ⋯).prod
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (Associates.mk ∘ ⇑normalize) (Classical.choose ⋯)).prod =
    (Multiset.map Associates.mk (Classical.choose ⋯)).prod

tactic: congr 2
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Multiset.map (Associates.mk ∘ ⇑normalize) (Classical.choose ⋯)).prod =
    (Multiset.map Associates.mk (Classical.choose ⋯)).prod
state_after: case e_a.e_f
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Associates.mk ∘ ⇑normalize = Associates.mk

tactic: ext
state_before: case e_a.e_f
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ Associates.mk ∘ ⇑normalize = Associates.mk
state_after: case e_a.e_f.h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
x✝ : α
⊢ (Associates.mk ∘ ⇑normalize) x✝ = Associates.mk x✝

tactic: rw [Function.comp_apply, Associates.mk_normalize]
state_before: case e_a.e_f.h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
x✝ : α
⊢ (Associates.mk ∘ ⇑normalize) x✝ = Associates.mk x✝
state_after: no goals
Theorem: AntilipschitzWith.comp
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: rw [ENNReal.coe_mul, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
Kg : ℝ≥0
g : β → γ
hg : AntilipschitzWith Kg g
Kf : ℝ≥0
f : α → β
hf : AntilipschitzWith Kf f
x y : α
⊢ ↑Kf * (↑Kg * edist (g (f x)) (g (f y))) = ↑(Kf * Kg) * edist ((g ∘ f) x) ((g ∘ f) y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
Kg : ℝ≥0
g : β → γ
hg : AntilipschitzWith Kg g
Kf : ℝ≥0
f : α → β
hf : AntilipschitzWith Kf f
x y : α
⊢ ↑Kf * (↑Kg * edist (g (f x)) (g (f y))) = ↑Kf * (↑Kg * edist ((g ∘ f) x) ((g ∘ f) y))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
Kg : ℝ≥0
g : β → γ
hg : AntilipschitzWith Kg g
Kf : ℝ≥0
f : α → β
hf : AntilipschitzWith Kf f
x y : α
⊢ ↑Kf * (↑Kg * edist (g (f x)) (g (f y))) = ↑Kf * (↑Kg * edist ((g ∘ f) x) ((g ∘ f) y))
state_after: no goals
Theorem: Submodule.snd_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [eq_top_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (LinearMap.snd R M M₂) (snd R M M₂) = ⊤
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.snd R M M₂) (snd R M M₂)

tactic: rintro x -
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.snd R M M₂) (snd R M M₂)
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (LinearMap.snd R M M₂) (snd R M M₂)

tactic: simp only [snd, comap_bot, mem_map, mem_ker, snd_apply, fst_apply,
  Prod.exists, exists_eq_right, exists_eq]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (LinearMap.snd R M M₂) (snd R M M₂)
state_after: no goals
Theorem: exists_opensMeasurableSpace_of_countablySeparated
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean

tactic: rcases exists_countablyGenerated_le_of_countablySeparated α with ⟨m', _, _, m'le⟩
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
α : Type u_5
m : MeasurableSpace α
inst✝ : CountablySeparated α
⊢ ∃ τ, SecondCountableTopology α ∧ T4Space α ∧ OpensMeasurableSpace α
state_after: case intro.intro.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
α : Type u_5
m : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : MeasurableSpace.SeparatesPoints α
m'le : m' ≤ m
⊢ ∃ τ, SecondCountableTopology α ∧ T4Space α ∧ OpensMeasurableSpace α

tactic: rcases exists_borelSpace_of_countablyGenerated_of_separatesPoints (m := m') with ⟨τ, _, _, τm'⟩
state_before: case intro.intro.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
α : Type u_5
m : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : MeasurableSpace.SeparatesPoints α
m'le : m' ≤ m
⊢ ∃ τ, SecondCountableTopology α ∧ T4Space α ∧ OpensMeasurableSpace α
state_after: case intro.intro.intro.intro.intro.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
α : Type u_5
m : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝³ : CountablyGenerated α
left✝² : MeasurableSpace.SeparatesPoints α
m'le : m' ≤ m
τ : TopologicalSpace α
left✝¹ : SecondCountableTopology α
left✝ : T4Space α
τm' : BorelSpace α
⊢ ∃ τ, SecondCountableTopology α ∧ T4Space α ∧ OpensMeasurableSpace α

tactic: exact ⟨τ, ‹_›, ‹_›, @OpensMeasurableSpace.mk _ _ m (τm'.measurable_eq.symm.le.trans m'le)⟩
state_before: case intro.intro.intro.intro.intro.intro
α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
α : Type u_5
m : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝³ : CountablyGenerated α
left✝² : MeasurableSpace.SeparatesPoints α
m'le : m' ≤ m
τ : TopologicalSpace α
left✝¹ : SecondCountableTopology α
left✝ : T4Space α
τm' : BorelSpace α
⊢ ∃ τ, SecondCountableTopology α ∧ T4Space α ∧ OpensMeasurableSpace α
state_after: no goals
Theorem: AddCommGroup.add_modEq_right
File: Mathlib/Algebra/ModEq.lean

tactic: simp [← modEq_sub_iff_add_modEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p]
state_after: no goals
Theorem: ProbabilityTheory.kernel.Invariant.comp_const
File: Mathlib/Probability/Kernel/Invariance.lean

tactic: rw [← const_bind_eq_comp_const κ μ, hκ.def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ η : ↥(kernel α α)
μ : Measure α
hκ : Invariant κ μ
⊢ κ ∘ₖ const α μ = const α μ
state_after: no goals
Theorem: Set.Ioo.one_minus_pos
File: Mathlib/Algebra/Order/Interval/Set/Instances.lean

tactic: simpa using x.2.2
state_before: α : Type u_1
inst✝¹ : StrictOrderedSemiring α
β : Type u_2
inst✝ : OrderedRing β
x : ↑(Ioo 0 1)
⊢ 0 < 1 - ↑x
state_after: no goals
Theorem: List.map₂Left_nil_right
File: Mathlib/Data/List/Basic.lean

tactic: cases as <;> rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option β → γ
as : List α
⊢ map₂Left f as [] = map (fun a => f a none) as
state_after: no goals
Theorem: Finset.insert_inter_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: have : ¬(x = a ∧ x ∈ s₂) := by rintro ⟨rfl, H⟩; exact h H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∉ s₂
x : α
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ s₁ ∩ s₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∉ s₂
x : α
this : ¬(x = a ∧ x ∈ s₂)
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ s₁ ∩ s₂

tactic: simp only [mem_inter, mem_insert, or_and_right, this, false_or_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∉ s₂
x : α
this : ¬(x = a ∧ x ∈ s₂)
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ s₁ ∩ s₂
state_after: no goals

tactic: rintro ⟨rfl, H⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∉ s₂
x : α
⊢ ¬(x = a ∧ x ∈ s₂)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x : α
H : x ∈ s₂
h : x ∉ s₂
⊢ False

tactic: exact h H
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x : α
H : x ∈ s₂
h : x ∉ s₂
⊢ False
state_after: no goals
Theorem: gal_prod_isSolvable
File: Mathlib/FieldTheory/AbelRuffini.lean

tactic: apply Multiset.induction_on' s
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
⊢ IsSolvable s.prod.Gal
state_after: case h₁
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
⊢ IsSolvable (Multiset.prod 0).Gal

case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
⊢ ∀ {a : F[X]} {s_1 : Multiset F[X]}, a ∈ s → s_1 ⊆ s → IsSolvable s_1.prod.Gal → IsSolvable (insert a s_1).prod.Gal

tactic: exact gal_one_isSolvable
state_before: case h₁
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
⊢ IsSolvable (Multiset.prod 0).Gal
state_after: no goals

tactic: intro p t hps _ ht
state_before: case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
⊢ ∀ {a : F[X]} {s_1 : Multiset F[X]}, a ∈ s → s_1 ⊆ s → IsSolvable s_1.prod.Gal → IsSolvable (insert a s_1).prod.Gal
state_after: case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
p : F[X]
t : Multiset F[X]
hps : p ∈ s
a✝ : t ⊆ s
ht : IsSolvable t.prod.Gal
⊢ IsSolvable (insert p t).prod.Gal

tactic: rw [Multiset.insert_eq_cons, Multiset.prod_cons]
state_before: case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
p : F[X]
t : Multiset F[X]
hps : p ∈ s
a✝ : t ⊆ s
ht : IsSolvable t.prod.Gal
⊢ IsSolvable (insert p t).prod.Gal
state_after: case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
p : F[X]
t : Multiset F[X]
hps : p ∈ s
a✝ : t ⊆ s
ht : IsSolvable t.prod.Gal
⊢ IsSolvable (p * t.prod).Gal

tactic: exact gal_mul_isSolvable (hs p hps) ht
state_before: case h₂
F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
s : Multiset F[X]
hs : ∀ p ∈ s, IsSolvable p.Gal
p : F[X]
t : Multiset F[X]
hps : p ∈ s
a✝ : t ⊆ s
ht : IsSolvable t.prod.Gal
⊢ IsSolvable (p * t.prod).Gal
state_after: no goals