1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Order.Ideal.isProper_of_not_mem
File: Mathlib/Order/Ideal.lean

tactic: have := mem_univ p
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
⊢ False
state_after: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ univ
⊢ False

tactic: rw [← hp] at this
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ univ
⊢ False
state_after: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ ↑I
⊢ False

tactic: exact nmem this
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ ↑I
⊢ False
state_after: no goals
Theorem: Ideal.map_toCotangent_ker
File: Mathlib/RingTheory/Ideal/Cotangent.lean

tactic: rw [Ideal.toCotangent, Submodule.ker_mkQ, pow_two, Submodule.map_smul'' I ⊤ (Submodule.subtype I),
  Algebra.id.smul_eq_mul, Submodule.map_subtype_top]
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent) = I ^ 2
state_after: no goals
Theorem: CategoryTheory.Sheaf.isSeparated
File: Mathlib/CategoryTheory/Sites/Whiskering.lean

tactic: rintro X S hS x y h
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁶ : Category.{v₂, u₂} A
B : Type u₃
inst✝⁵ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F✝ G H : A ⥤ B
η : F✝ ⟶ G
γ : G ⟶ H
inst✝⁴ : J.HasSheafCompose F✝
inst✝³ : J.HasSheafCompose G
inst✝² : J.HasSheafCompose H
inst✝¹ : ConcreteCategory A
inst✝ : J.HasSheafCompose (forget A)
F : Sheaf J A
⊢ Presheaf.IsSeparated J F.val
state_after: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁶ : Category.{v₂, u₂} A
B : Type u₃
inst✝⁵ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F✝ G H : A ⥤ B
η : F✝ ⟶ G
γ : G ⟶ H
inst✝⁴ : J.HasSheafCompose F✝
inst✝³ : J.HasSheafCompose G
inst✝² : J.HasSheafCompose H
inst✝¹ : ConcreteCategory A
inst✝ : J.HasSheafCompose (forget A)
F : Sheaf J A
X : C
S : Sieve X
hS : S ∈ J.sieves X
x y : (forget A).obj (F.val.obj { unop := X })
h : ∀ (Y : C) (f : Y ⟶ X), S.arrows f → (F.val.map f.op) x = (F.val.map f.op) y
⊢ x = y

tactic: exact (Presieve.isSeparated_of_isSheaf _ _ ((isSheaf_iff_isSheaf_of_type _ _).1
  ((sheafCompose J (forget A)).obj F).2) S hS).ext (fun _ _ hf => h _ _ hf)
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁶ : Category.{v₂, u₂} A
B : Type u₃
inst✝⁵ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F✝ G H : A ⥤ B
η : F✝ ⟶ G
γ : G ⟶ H
inst✝⁴ : J.HasSheafCompose F✝
inst✝³ : J.HasSheafCompose G
inst✝² : J.HasSheafCompose H
inst✝¹ : ConcreteCategory A
inst✝ : J.HasSheafCompose (forget A)
F : Sheaf J A
X : C
S : Sieve X
hS : S ∈ J.sieves X
x y : (forget A).obj (F.val.obj { unop := X })
h : ∀ (Y : C) (f : Y ⟶ X), S.arrows f → (F.val.map f.op) x = (F.val.map f.op) y
⊢ x = y
state_after: no goals
Theorem: AEMeasurable.exists_measurable_nonneg
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: obtain ⟨G, hG_meas, hG_mem, hG_ae_eq⟩ := hf.exists_ae_eq_range_subset f_nn ⟨0, le_rfl⟩
state_before: ι : Type u_1
α : Type u_2
β✝ : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
f✝ g : α → β✝
μ ν : Measure α
β : Type u_7
inst✝¹ : Preorder β
inst✝ : Zero β
mβ : MeasurableSpace β
f : α → β
hf : AEMeasurable f μ
f_nn : ∀ᵐ (t : α) ∂μ, 0 ≤ f t
⊢ ∃ g, Measurable g ∧ 0 ≤ g ∧ f =ᶠ[ae μ] g
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β✝ : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
f✝ g : α → β✝
μ ν : Measure α
β : Type u_7
inst✝¹ : Preorder β
inst✝ : Zero β
mβ : MeasurableSpace β
f : α → β
hf : AEMeasurable f μ
f_nn : ∀ᵐ (t : α) ∂μ, 0 ≤ f t
G : α → β
hG_meas : Measurable G
hG_mem : range G ⊆ Preorder.toLE.1 0
hG_ae_eq : f =ᶠ[ae μ] G
⊢ ∃ g, Measurable g ∧ 0 ≤ g ∧ f =ᶠ[ae μ] g

tactic: exact ⟨G, hG_meas, fun x => hG_mem (mem_range_self x), hG_ae_eq⟩
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β✝ : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝⁴ : MeasurableSpace β✝
inst✝³ : MeasurableSpace γ
inst✝² : MeasurableSpace δ
f✝ g : α → β✝
μ ν : Measure α
β : Type u_7
inst✝¹ : Preorder β
inst✝ : Zero β
mβ : MeasurableSpace β
f : α → β
hf : AEMeasurable f μ
f_nn : ∀ᵐ (t : α) ∂μ, 0 ≤ f t
G : α → β
hG_meas : Measurable G
hG_mem : range G ⊆ Preorder.toLE.1 0
hG_ae_eq : f =ᶠ[ae μ] G
⊢ ∃ g, Measurable g ∧ 0 ≤ g ∧ f =ᶠ[ae μ] g
state_after: no goals
Theorem: CategoryTheory.Localization.isoOfHom_id_inv
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: rw [← cancel_mono (isoOfHom L W (𝟙 X) hX).hom, Iso.inv_hom_id, id_comp,
  isoOfHom_hom, Functor.map_id]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.11461, u_3} E
inst✝ : L.IsLocalization W
X : C
hX : W (𝟙 X)
⊢ (isoOfHom L W (𝟙 X) hX).inv = 𝟙 (L.obj X)
state_after: no goals
Theorem: UniformEquiv.uniformInducing
File: Mathlib/Topology/UniformSpace/Equiv.lean

tactic: simp only [symm_comp_self, uniformInducing_id]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : UniformSpace δ
h : α ≃ᵤ β
⊢ UniformInducing (⇑h.symm ∘ ⇑h)
state_after: no goals
Theorem: ULift.down_injective
File: Mathlib/Logic/Basic.lean

tactic: congr
state_before: α✝ : Sort u_1
α : Type u_2
a b : α
x✝ : { down := a }.down = { down := b }.down
⊢ { down := a } = { down := b }
state_after: no goals
Theorem: Matroid.base_restrict_iff
File: Mathlib/Data/Matroid/Restrict.lean

tactic: simp_rw [base_iff_maximal_indep, basis_iff', restrict_indep_iff, and_iff_left hX, and_assoc]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ (M ↾ X).Base I ↔ M.Basis I X
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ (M.Indep I ∧ I ⊆ X ∧ ∀ (I_1 : Set α), M.Indep I_1 ∧ I_1 ⊆ X → I ⊆ I_1 → I = I_1) ↔
    M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J

tactic: aesop
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ (M.Indep I ∧ I ⊆ X ∧ ∀ (I_1 : Set α), M.Indep I_1 ∧ I_1 ⊆ X → I ⊆ I_1 → I = I_1) ↔
    M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J
state_after: no goals
Theorem: Set.Finite.induction_on
File: Mathlib/Data/Set/Finite.lean

tactic: lift s to Finset α using h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
s : Set α
h : s.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
⊢ C s
state_after: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
s : Finset α
⊢ C ↑s

tactic: induction' s using Finset.cons_induction_on with a s ha hs
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
s : Finset α
⊢ C ↑s
state_after: case intro.h₁
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
⊢ C ↑∅

case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
a : α
s : Finset α
ha : a ∉ s
hs : C ↑s
⊢ C ↑(Finset.cons a s ha)

tactic: rwa [Finset.coe_empty]
state_before: case intro.h₁
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
⊢ C ↑∅
state_after: no goals

tactic: rw [Finset.coe_cons]
state_before: case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
a : α
s : Finset α
ha : a ∉ s
hs : C ↑s
⊢ C ↑(Finset.cons a s ha)
state_after: case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
a : α
s : Finset α
ha : a ∉ s
hs : C ↑s
⊢ C (insert a ↑s)

tactic: exact @H1 a s ha (Set.toFinite _) hs
state_before: case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → C s → C (insert a s)
a : α
s : Finset α
ha : a ∉ s
hs : C ↑s
⊢ C (insert a ↑s)
state_after: no goals
Theorem: Ordinal.type_ne_zero_iff_nonempty
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder α r
⊢ type r ≠ 0 ↔ Nonempty α
state_after: no goals
Theorem: IsUpperSet.mul_left
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (s * t)
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (⋃ a ∈ s, a • t)

tactic: exact isUpperSet_iUnion₂ fun x _ ↦ ht.smul
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
ht : IsUpperSet t
⊢ IsUpperSet (⋃ a ∈ s, a • t)
state_after: no goals
Theorem: FirstOrder.Ring.realize_termOfFreeCommRing
File: Mathlib/ModelTheory/Algebra/Ring/FreeCommRing.lean

tactic: let _ := compatibleRingOfRing (FreeCommRing α)
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p

tactic: rw [termOfFreeCommRing]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (termOfFreeCommRing p) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) p

tactic: conv_rhs => rw [← Classical.choose_spec (exists_term_realize_eq_freeCommRing p)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) p
state_after: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (Classical.choose ⋯))

tactic: induction Classical.choose (exists_term_realize_eq_freeCommRing p) with
| var _ => simp
| func f a ih =>
  cases f <;>
  simp [ih]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
⊢ Term.realize v (Classical.choose ⋯) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (Classical.choose ⋯))
state_after: no goals

tactic: simp
state_before: case var
α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
a✝ : α
⊢ Term.realize v (var a✝) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (var a✝))
state_after: no goals

tactic: cases f <;>
simp [ih]
state_before: case func
α : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : CompatibleRing R
p : FreeCommRing α
v : α → R
x✝ : CompatibleRing (FreeCommRing α) := compatibleRingOfRing (FreeCommRing α)
l✝ : ℕ
f : ring.Functions l✝
a : Fin l✝ → ring.Term α
ih : ∀ (a_1 : Fin l✝), Term.realize v (a a_1) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (a a_1))
⊢ Term.realize v (func f a) = (FreeCommRing.lift v) (Term.realize FreeCommRing.of (func f a))
state_after: no goals
Theorem: Nat.xor_self
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp
state_before: n i : ℕ
⊢ (n ^^^ n).testBit i = false
state_after: no goals
Theorem: Orientation.rotation_pi
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

tactic: ext x
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
⊢ o.rotation ↑π = LinearIsometryEquiv.neg ℝ
state_after: case h
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ (o.rotation ↑π) x = (LinearIsometryEquiv.neg ℝ) x

tactic: simp [rotation]
state_before: case h
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
⊢ (o.rotation ↑π) x = (LinearIsometryEquiv.neg ℝ) x
state_after: no goals
Theorem: WithBot.lt_coe_bot
File: Mathlib/Order/WithBot.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : OrderBot α
x : α
⊢ ↑x < ↑⊥ ↔ ↑x = ⊥
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : OrderBot α
⊢ ⊥ < ↑⊥ ↔ ⊥ = ⊥
state_after: no goals
Theorem: Metric.cthickening_singleton
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: ext y
state_before: ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
⊢ cthickening δ {x} = closedBall x δ
state_after: case h
ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
y : α
⊢ y ∈ cthickening δ {x} ↔ y ∈ closedBall x δ

tactic: simp [cthickening, edist_dist, ENNReal.ofReal_le_ofReal_iff hδ]
state_before: case h
ι : Sort u_1
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ✝ ε : ℝ
s t : Set α✝
x✝ : α✝
α : Type u_2
inst✝ : PseudoMetricSpace α
x : α
δ : ℝ
hδ : 0 ≤ δ
y : α
⊢ y ∈ cthickening δ {x} ↔ y ∈ closedBall x δ
state_after: no goals
Theorem: MonotoneOn.image_upperBounds_subset_upperBounds_image
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, ha, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
Hf : MonotoneOn f t
a : α
Hst✝ Hst : s ⊆ t
⊢ f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
Hf : MonotoneOn f t
a✝ : α
Hst✝ Hst : s ⊆ t
a : α
ha : a ∈ upperBounds s ∩ t
⊢ f a ∈ upperBounds (f '' s)

tactic: exact Hf.mem_upperBounds_image Hst ha.1 ha.2
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
Hf : MonotoneOn f t
a✝ : α
Hst✝ Hst : s ⊆ t
a : α
ha : a ∈ upperBounds s ∩ t
⊢ f a ∈ upperBounds (f '' s)
state_after: no goals
Theorem: Batteries.RBNode.find?_eq_zoom
File: .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean

tactic: unfold find? zoom
state_before: α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : optParam (Path α) Path.root
⊢ find? cut (node c✝ l✝ v✝ r✝) = (zoom cut (node c✝ l✝ v✝ r✝) x✝).fst.root?
state_after: α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : optParam (Path α) Path.root
⊢ (match cut v✝ with
    | Ordering.lt => find? cut l✝
    | Ordering.gt => find? cut r✝
    | Ordering.eq => some v✝) =
    (match cut v✝ with
        | Ordering.lt => zoom cut l✝ (Path.left c✝ x✝ v✝ r✝)
        | Ordering.gt => zoom cut r✝ (Path.right c✝ l✝ v✝ x✝)
        | Ordering.eq => (node c✝ l✝ v✝ r✝, x✝)).fst.root?

tactic: split <;> [apply find?_eq_zoom; apply find?_eq_zoom; rfl]
state_before: α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : optParam (Path α) Path.root
⊢ (match cut v✝ with
    | Ordering.lt => find? cut l✝
    | Ordering.gt => find? cut r✝
    | Ordering.eq => some v✝) =
    (match cut v✝ with
        | Ordering.lt => zoom cut l✝ (Path.left c✝ x✝ v✝ r✝)
        | Ordering.gt => zoom cut r✝ (Path.right c✝ l✝ v✝ x✝)
        | Ordering.eq => (node c✝ l✝ v✝ r✝, x✝)).fst.root?
state_after: no goals
Theorem: Surreal.Multiplication.P3_of_le_left
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: obtain (hl|he) := lt_or_equiv_of_le hl
state_before: x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂
state_after: case inl
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl✝ : x₁ ≤ x₂.moveLeft i
hl : x₁ < x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂

case inr
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
he : x₁ ≈ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂

tactic: exact (h.2.2.2 hl).trans h.2.2.1
state_before: case inl
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl✝ : x₁ ≤ x₂.moveLeft i
hl : x₁ < x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂
state_after: no goals

tactic: rw [P3, h.1 he, h.2.1 he]
state_before: case inr
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
he : x₁ ≈ x₂.moveLeft i
⊢ P3 x₁ x₂ y₁ y₂
state_after: case inr
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
he : x₁ ≈ x₂.moveLeft i
⊢ ⟦x₂.moveLeft i * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₂.moveLeft i * y₁⟧ + ⟦x₂ * y₂⟧

tactic: exact h.2.2.1
state_before: case inr
x x₁ x₂ x₃ x' y y₁✝ y₂✝ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hx : x.Numeric
hy : y.Numeric
ih' : ∀ (a : Args), ArgsRel a (Args.P24 x₁ x₂ y) → P124 a
y₁ y₂ : PGame
i : x₂.LeftMoves
h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂
hl : x₁ ≤ x₂.moveLeft i
he : x₁ ≈ x₂.moveLeft i
⊢ ⟦x₂.moveLeft i * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₂.moveLeft i * y₁⟧ + ⟦x₂ * y₂⟧
state_after: no goals
Theorem: PosNum.pred'_succ'
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [pred'_to_nat, succ'_to_nat, Nat.add_one, Nat.pred_succ]
state_before: α : Type u_1
n : Num
⊢ ↑n.succ'.pred' = ↑n
state_after: no goals
Theorem: MvPolynomial.vars_sub_subset
File: Mathlib/Algebra/MvPolynomial/CommRing.lean

tactic: convert vars_add_subset p (-q) using 2 <;> simp [sub_eq_add_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommRing R
p q : MvPolynomial σ R
inst✝ : DecidableEq σ
⊢ (p - q).vars ⊆ p.vars ∪ q.vars
state_after: no goals
Theorem: Sym.card_sym_fin_eq_multichoose
File: Mathlib/Data/Sym/Card.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
n✝ n : ℕ
⊢ Fintype.card (Sym (Fin n) 0) = n.multichoose 0
state_after: no goals

tactic: rw [multichoose_zero_succ]
state_before: α : Type u_1
β : Type u_2
n k : ℕ
⊢ Fintype.card (Sym (Fin 0) (k + 1)) = multichoose 0 (k + 1)
state_after: α : Type u_1
β : Type u_2
n k : ℕ
⊢ Fintype.card (Sym (Fin 0) (k + 1)) = 0

tactic: exact card_eq_zero
state_before: α : Type u_1
β : Type u_2
n k : ℕ
⊢ Fintype.card (Sym (Fin 0) (k + 1)) = 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
n k : ℕ
⊢ Fintype.card (Sym (Fin 1) (k + 1)) = multichoose 1 (k + 1)
state_after: no goals

tactic: rw [multichoose_succ_succ, ← card_sym_fin_eq_multichoose (n + 1) (k + 1),
  ← card_sym_fin_eq_multichoose (n + 2) k, add_comm (Fintype.card _), ← card_sum]
state_before: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ Fintype.card (Sym (Fin (n + 2)) (k + 1)) = (n + 2).multichoose (k + 1)
state_after: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ Fintype.card (Sym (Fin (n + 2)) (k + 1)) = Fintype.card (Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1))

tactic: refine Fintype.card_congr (Equiv.symm ?_)
state_before: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ Fintype.card (Sym (Fin (n + 2)) (k + 1)) = Fintype.card (Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1))
state_after: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1) ≃ Sym (Fin (n + 2)) (k + 1)

tactic: apply (Sym.e1.symm.sumCongr Sym.e2.symm).trans
state_before: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1) ≃ Sym (Fin (n + 2)) (k + 1)
state_after: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ { s // 0 ∈ s } ⊕ { s // 0 ∉ s } ≃ Sym (Fin (n + 2)) (k + 1)

tactic: apply Equiv.sumCompl
state_before: α : Type u_1
β : Type u_2
n✝ n k : ℕ
⊢ { s // 0 ∈ s } ⊕ { s // 0 ∉ s } ≃ Sym (Fin (n + 2)) (k + 1)
state_after: no goals