ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.GradedObject.mapBifunctorMap_obj_map
File: Mathlib/CategoryTheory/GradedObject/Bifunctor.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝³ : Category.{?u.42329, u_1} C₁
inst✝² : Category.{?u.42333, u_2} C₂
inst✝¹ : Category.{?u.42337, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
inst✝ : ∀ (X : GradedObject I C₁) (Y : GradedObject J C₂), (((mapBifunctor F I J).obj X).obj Y).HasMap p
X₁ X₂ : GradedObject I C₁
φ : X₁ ⟶ X₂
Y₁ Y₂ : GradedObject J C₂
ψ : Y₁ ⟶ Y₂
⊢ ((fun X =>
              { obj := fun Y => mapBifunctorMapObj F p X Y, map := fun {X_1 Y} ψ => mapBifunctorMapMap F p (𝟙 X) ψ,
                map_id := ⋯, map_comp := ⋯ })
            X₁).map
        ψ ≫
      (fun Y => mapBifunctorMapMap F p φ (𝟙 Y)) Y₂ =
    (fun Y => mapBifunctorMapMap F p φ (𝟙 Y)) Y₁ ≫
      ((fun X =>
              { obj := fun Y => mapBifunctorMapObj F p X Y, map := fun {X_1 Y} ψ => mapBifunctorMapMap F p (𝟙 X) ψ,
                map_id := ⋯, map_comp := ⋯ })
            X₂).map
        ψ
state_after: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝³ : Category.{?u.42329, u_1} C₁
inst✝² : Category.{?u.42333, u_2} C₂
inst✝¹ : Category.{?u.42337, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
inst✝ : ∀ (X : GradedObject I C₁) (Y : GradedObject J C₂), (((mapBifunctor F I J).obj X).obj Y).HasMap p
X₁ X₂ : GradedObject I C₁
φ : X₁ ⟶ X₂
Y₁ Y₂ : GradedObject J C₂
ψ : Y₁ ⟶ Y₂
⊢ mapMap (((mapBifunctor F I J).map (𝟙 X₁)).app Y₁ ≫ ((mapBifunctor F I J).obj X₁).map ψ) p ≫
      mapMap (((mapBifunctor F I J).map φ).app Y₂ ≫ ((mapBifunctor F I J).obj X₂).map (𝟙 Y₂)) p =
    mapMap (((mapBifunctor F I J).map φ).app Y₁ ≫ ((mapBifunctor F I J).obj X₂).map (𝟙 Y₁)) p ≫
      mapMap (((mapBifunctor F I J).map (𝟙 X₂)).app Y₁ ≫ ((mapBifunctor F I J).obj X₂).map ψ) p
tactic: dsimp
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝³ : Category.{?u.42329, u_1} C₁
inst✝² : Category.{?u.42333, u_2} C₂
inst✝¹ : Category.{?u.42337, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
inst✝ : ∀ (X : GradedObject I C₁) (Y : GradedObject J C₂), (((mapBifunctor F I J).obj X).obj Y).HasMap p
X₁ X₂ : GradedObject I C₁
φ : X₁ ⟶ X₂
Y₁ Y₂ : GradedObject J C₂
ψ : Y₁ ⟶ Y₂
⊢ mapMap (((mapBifunctor F I J).map (𝟙 X₁)).app Y₁ ≫ ((mapBifunctor F I J).obj X₁).map ψ) p ≫
      mapMap (((mapBifunctor F I J).map φ).app Y₂ ≫ ((mapBifunctor F I J).obj X₂).map (𝟙 Y₂)) p =
    mapMap (((mapBifunctor F I J).map φ).app Y₁ ≫ ((mapBifunctor F I J).obj X₂).map (𝟙 Y₁)) p ≫
      mapMap (((mapBifunctor F I J).map (𝟙 X₂)).app Y₁ ≫ ((mapBifunctor F I J).obj X₂).map ψ) p
state_after: no goals
tactic: simp only [Functor.map_id, NatTrans.id_app, id_comp, comp_id,
          ← mapMap_comp, NatTrans.naturality]
Theorem: Complex.ringHom_eq_id_or_conj_of_continuous
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ →+* ℂ
hf : Continuous ⇑f
⊢ f = RingHom.id ℂ ∨ f = starRingEnd ℂ
state_after: no goals
tactic: simpa only [DFunLike.ext_iff] using real_algHom_eq_id_or_conj (AlgHom.mk' f (map_real_smul f hf))
Theorem: ContractingWith.dist_fixedPoint_fixedPoint_of_dist_le'
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
g : α → α
x y : α
hx : IsFixedPt f x
hy : IsFixedPt g y
C : ℝ
hfg : ∀ (z : α), dist (f z) (g z) ≤ C
⊢ dist y (f y) / (1 - ↑K) = dist (f y) (g y) / (1 - ↑K)
state_after: no goals
tactic: rw [hy.eq, dist_comm]
Theorem: Finsupp.lmapDomain_total
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
⊢ Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f = g ∘ₗ Finsupp.total α M R v
state_after: case h.h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
l : α
⊢ ((Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f) ∘ₗ lsingle l) 1 = ((g ∘ₗ Finsupp.total α M R v) ∘ₗ lsingle l) 1
tactic: ext l
state_before: case h.h
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
f : α → α'
g : M →ₗ[R] M'
h : ∀ (i : α), g (v i) = v' (f i)
l : α
⊢ ((Finsupp.total α' M' R v' ∘ₗ lmapDomain R R f) ∘ₗ lsingle l) 1 = ((g ∘ₗ Finsupp.total α M R v) ∘ₗ lsingle l) 1
state_after: no goals
tactic: simp [total_apply, Finsupp.sum_mapDomain_index, add_smul, h]
Theorem: Nat.sub_eq_of_eq_add'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a = b + c
⊢ a - b = c
state_after: no goals
tactic: rw [h, Nat.add_sub_cancel_left]
Theorem: AddSubgroup.MemLeftTransversals.finite_iff
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ leftTransversals ↑H
⊢ Finite ↑S ↔ H.FiniteIndex
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ leftTransversals ↑H
⊢ Finite (G ⧸ H) ↔ H.FiniteIndex
tactic: rw [← (Subgroup.MemLeftTransversals.toEquiv h).finite_iff]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : S ∈ leftTransversals ↑H
⊢ Finite (G ⧸ H) ↔ H.FiniteIndex
state_after: no goals
tactic: exact ⟨fun _ ↦ finiteIndex_of_finite_quotient H, fun _ ↦ finite_quotient_of_finiteIndex H⟩
Theorem: MvPolynomial.vars_sum_subset
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_3
t : Finset ι
φ : ι → MvPolynomial σ R
inst✝ : DecidableEq σ
⊢ (∑ i ∈ t, φ i).vars ⊆ t.biUnion fun i => (φ i).vars
state_after: no goals
tactic: classical
  induction t using Finset.induction_on with
  | empty => simp
  | insert has hsum =>
    rw [Finset.biUnion_insert, Finset.sum_insert has]
    refine Finset.Subset.trans
      (vars_add_subset _ _) (Finset.union_subset_union (Finset.Subset.refl _) ?_)
    assumption
Theorem: Subalgebra.range_algebraMap
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R✝ : Type u
A✝ : Type v
B : Type w
inst✝⁷ : CommSemiring R✝
inst✝⁶ : Semiring A✝
inst✝⁵ : Algebra R✝ A✝
inst✝⁴ : Semiring B
inst✝³ : Algebra R✝ B
S✝ : Subalgebra R✝ A✝
α : Type u_1
β : Type u_2
R : Type u_3
A : Type u_4
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
S : Subalgebra R A
⊢ (algebraMap (↥S) A).range = S.toSubring
state_after: no goals
tactic: rw [algebraMap_eq, Algebra.id.map_eq_id, RingHom.id_comp, ← toSubring_subtype,
    Subring.range_subtype]
Theorem: isNormalAddSubgroup_of_addCommGroup
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : CommGroup G
s : Set G
hs : IsSubgroup s
n : G
hn : n ∈ s
g : G
⊢ g * n * g⁻¹ ∈ s
state_after: no goals
tactic: rwa [mul_right_comm, mul_right_inv, one_mul]
Theorem: Nat.Partrec'.of_part
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
⊢ Partrec' f
state_after: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
⊢ Partrec' f
tactic: let g := fun n₁ =>
        (Part.ofOption (decode (α := Vector ℕ n) n₁)).bind (fun a => Part.map encode (f a))
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f v.head
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => (↑(decode n₁)).bind fun a => Part.map encode (f a)
⊢ Partrec' f
state_after: no goals
tactic: exact
        (comp₁ g (this g hf) (prim Nat.Primrec'.encode)).of_eq fun i => by
          dsimp only [g]; simp [encodek, Part.map_id']
state_before: f : ℕ →. ℕ
hf : Partrec f
⊢ Partrec' fun v => f v.head
state_after: case intro
c : Code
hf : Partrec c.eval
⊢ Partrec' fun v => c.eval v.head
tactic: obtain ⟨c, rfl⟩ := exists_code.1 hf
state_before: case intro
c : Code
hf : Partrec c.eval
⊢ Partrec' fun v => c.eval v.head
state_after: no goals
tactic: simpa [eval_eq_rfindOpt] using
      rfindOpt <|
        of_prim <|
          Primrec.encode_iff.2 <|
            evaln_prim.comp <|
              (Primrec.vector_head.pair (_root_.Primrec.const c)).pair <|
                Primrec.vector_head.comp Primrec.vector_tail
Theorem: RCLike.complexLinearIsometryEquiv_invFun
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ { toFun := __spread✝⁻⁰.toFun, map_add' := ⋯ }.toFun (x✝¹ • x✝) =
    (RingHom.id ℝ) x✝¹ • { toFun := __spread✝⁻⁰.toFun, map_add' := ⋯ }.toFun x✝
state_after: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ ↑x✝¹ * ↑(RCLike.im x✝) * I = ↑x✝¹ * (↑(RCLike.im x✝) * I)
tactic: simp [RCLike.smul_re, RCLike.smul_im, ofReal_mul]
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ ↑x✝¹ * ↑(RCLike.im x✝) * I = ↑x✝¹ * (↑(RCLike.im x✝) * I)
state_after: no goals
tactic: ring
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ ‖{ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝‖ =
    ‖x✝‖
state_after: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ normSq
      ({ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝) =
    RCLike.re x✝ * RCLike.re x✝ + RCLike.im x✝ * RCLike.im x✝
tactic: rw [← sq_eq_sq (by positivity) (by positivity), ← normSq_eq_norm_sq, ← RCLike.normSq_eq_def',
      RCLike.normSq_apply]
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ normSq
      ({ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝) =
    RCLike.re x✝ * RCLike.re x✝ + RCLike.im x✝ * RCLike.im x✝
state_after: no goals
tactic: simp [normSq_add]
Theorem: Ordinal.unbounded_of_unbounded_iUnion
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃ x, s x)
h₂ : #β < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)
state_after: α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range s)
h₂ : #β < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)
tactic: rw [← sUnion_range] at h₁
state_before: α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range s)
h₂ : #β < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)
state_after: case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range s)
h₂ : #β < StrictOrder.cof r
x : β
u : Unbounded r (s x)
⊢ ∃ x, Unbounded r (s x)
tactic: rcases unbounded_of_unbounded_sUnion r h₁ (mk_range_le.trans_lt h₂) with ⟨_, ⟨x, rfl⟩, u⟩
state_before: case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range s)
h₂ : #β < StrictOrder.cof r
x : β
u : Unbounded r (s x)
⊢ ∃ x, Unbounded r (s x)
state_after: no goals
tactic: exact ⟨x, u⟩
Theorem: Filter.HasBasis.restrict
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
⊢ l.HasBasis (fun i => p i ∧ q i) s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
tactic: refine ⟨fun t => ⟨fun ht => ?_, fun ⟨i, hpi, hti⟩ => h.mem_iff.2 ⟨i, hpi.1, hti⟩⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
tactic: rcases h.mem_iff.1 ht with ⟨i, hpi, hti⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
state_after: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
j : ι
hpj : p j
hqj : q j
hji : s j ⊆ s i
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
tactic: rcases hq i hpi with ⟨j, hpj, hqj, hji⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
q : ι → Prop
hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i
t : Set α
ht : t ∈ l
i : ι
hpi : p i
hti : s i ⊆ t
j : ι
hpj : p j
hqj : q j
hji : s j ⊆ s i
⊢ ∃ i, (p i ∧ q i) ∧ s i ⊆ t
state_after: no goals
tactic: exact ⟨j, ⟨hpj, hqj⟩, hji.trans hti⟩
Theorem: MeasureTheory.Integrable.smul_of_top_left
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hφ : Integrable φ μ
hf : Memℒp f ⊤ μ
⊢ Integrable (φ • f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hφ : Memℒp φ 1 μ
hf : Memℒp f ⊤ μ
⊢ Memℒp (φ • f) 1 μ
tactic: rw [← memℒp_one_iff_integrable] at hφ ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hφ : Memℒp φ 1 μ
hf : Memℒp f ⊤ μ
⊢ Memℒp (φ • f) 1 μ
state_after: no goals
tactic: exact Memℒp.smul_of_top_left hf hφ
Theorem: Multiset.singleton_eq_cons_iff
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
m : Multiset α
⊢ {a} = b ::ₘ m ↔ a = b ∧ m = 0
state_after: α : Type u_1
β : Type v
γ : Type u_2
a b : α
m : Multiset α
⊢ (a = b ∧ 0 = m ∨ a ≠ b ∧ ∃ cs, 0 = b ::ₘ cs ∧ m = a ::ₘ cs) ↔ a = b ∧ m = 0
tactic: rw [← cons_zero, cons_eq_cons]
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
m : Multiset α
⊢ (a = b ∧ 0 = m ∨ a ≠ b ∧ ∃ cs, 0 = b ::ₘ cs ∧ m = a ::ₘ cs) ↔ a = b ∧ m = 0
state_after: no goals
tactic: simp [eq_comm]
Theorem: Matrix.kroneckerMap_diagonal_right
File: Mathlib/Data/Matrix/Kronecker.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
⊢ kroneckerMap f A (diagonal b) = blockDiagonal fun i => A.map fun a => f a (b i)
state_after: case a.mk.mk
R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
i₁ : l
i₂ : n
j₁ : m
j₂ : n
⊢ kroneckerMap f A (diagonal b) (i₁, i₂) (j₁, j₂) = blockDiagonal (fun i => A.map fun a => f a (b i)) (i₁, i₂) (j₁, j₂)
tactic: ext ⟨i₁, i₂⟩ ⟨j₁, j₂⟩
state_before: case a.mk.mk
R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
i₁ : l
i₂ : n
j₁ : m
j₂ : n
⊢ kroneckerMap f A (diagonal b) (i₁, i₂) (j₁, j₂) = blockDiagonal (fun i => A.map fun a => f a (b i)) (i₁, i₂) (j₁, j₂)
state_after: no goals
tactic: simp [diagonal, blockDiagonal, apply_ite (f (A i₁ j₁)), hf]
Theorem: Pell.xn_ge_a_pow
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ (n + 1) ≤ xn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ n * a ≤ xn a1 n * a + Pell.d a1 * yn a1 n
tactic: simp only [_root_.pow_succ, xn_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ n * a ≤ xn a1 n * a + Pell.d a1 * yn a1 n
state_after: no goals
tactic: exact le_trans (Nat.mul_le_mul_right _ (xn_ge_a_pow n)) (Nat.le_add_right _ _)
Theorem: AddAction.orbitRel.Quotient.orbit_injective
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
⊢ Injective orbit
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x y : Quotient G α
h : x.orbit = y.orbit
⊢ x = y
tactic: intro x y h
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x y : Quotient G α
h : x.orbit = y.orbit
⊢ x = y
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x y : Quotient G α
h : Setoid.r (Quotient.out' x) (Quotient.out' y)
⊢ x = y
tactic: simp_rw [orbitRel.Quotient.orbit_eq_orbit_out _ Quotient.out_eq', orbit_eq_iff,
    ← orbitRel_r_apply] at h
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x y : Quotient G α
h : Setoid.r (Quotient.out' x) (Quotient.out' y)
⊢ x = y
state_after: no goals
tactic: simpa [← Quotient.eq''] using h
Theorem: MeasurableSpace.generateFrom_empty
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
⊢ ∀ t ∈ ∅, MeasurableSet t
state_after: no goals
tactic: simp
Theorem: CategoryTheory.monoidalComp_refl
File: Mathlib/Tactic/CategoryTheory/MonoidalComp.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ f ⊗≫ g = f ≫ g
state_after: no goals
tactic: simp [monoidalComp]
Theorem: linearIndependent_comp_subtype_disjoint
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set ι
⊢ LinearIndependent (ι := ↑s) R (v ∘ Subtype.val) ↔
    Disjoint (Finsupp.supported R R s) (LinearMap.ker (Finsupp.total ι M R v))
state_after: no goals
tactic: rw [linearIndependent_comp_subtype, LinearMap.disjoint_ker]
Theorem: Computation.liftRel_think_right
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
⊢ LiftRel R ca cb.think ↔ LiftRel R ca cb
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
⊢ LiftRel (swap R) cb.think ca ↔ LiftRel (swap R) cb ca
tactic: rw [← LiftRel.swap R, ← LiftRel.swap R]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
⊢ LiftRel (swap R) cb.think ca ↔ LiftRel (swap R) cb ca
state_after: no goals
tactic: apply liftRel_think_left
Theorem: CategoryTheory.Quotient.comp_natTransLift
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H✝ : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G H : Quotient r ⥤ D
τ : functor r ⋙ F ⟶ functor r ⋙ G
τ' : functor r ⋙ G ⟶ functor r ⋙ H
⊢ natTransLift r τ ≫ natTransLift r τ' = natTransLift r (τ ≫ τ')
state_after: no goals
tactic: aesop_cat
Theorem: AddCommGroup.modEq_iff_toIocMod_eq_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ a ≡ b [PMOD p] ↔ toIocMod hp a b = a + p
state_after: case refine_1
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (∃ z, b = a + z • p) → toIocMod hp a b = a + p

case refine_2
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h : toIocMod hp a b = a + p
⊢ b = a + (toIocDiv hp a b + 1) • p
tactic: refine modEq_iff_eq_add_zsmul.trans ⟨?_, fun h => ⟨toIocDiv hp a b + 1, ?_⟩⟩