ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BumpCovering.toPOUFun_eq_mul_prod
File: Mathlib/Topology/PartitionOfUnity.lean

Proof steps:
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
⊢ f.toPOUFun i x = (f i) x * ∏ j ∈ Finset.filter (fun j => WellOrderingRel j i) t, (1 - (f j) x)
state_after: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : 1 - (f j) x ≠ 1
⊢ WellOrderingRel j i ↔ j ∈ Finset.filter (fun j => WellOrderingRel j i) t
tactic: refine congr_arg _ (finprod_cond_eq_prod_of_cond_iff _ fun {j} hj => ?_)
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : 1 - (f j) x ≠ 1
⊢ WellOrderingRel j i ↔ j ∈ Finset.filter (fun j => WellOrderingRel j i) t
state_after: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : ¬(f j) x = 0
⊢ WellOrderingRel j i ↔ j ∈ Finset.filter (fun j => WellOrderingRel j i) t
tactic: rw [Ne, sub_eq_self] at hj
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : ¬(f j) x = 0
⊢ WellOrderingRel j i ↔ j ∈ Finset.filter (fun j => WellOrderingRel j i) t
state_after: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : ¬(f j) x = 0
⊢ WellOrderingRel j i → j ∈ t
tactic: rw [Finset.mem_filter, Iff.comm, and_iff_right_iff_imp]
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
t : Finset ι
ht : ∀ (j : ι), WellOrderingRel j i → (f j) x ≠ 0 → j ∈ t
j : ι
hj : ¬(f j) x = 0
⊢ WellOrderingRel j i → j ∈ t
state_after: no goals
tactic: exact flip (ht j) hj
Theorem: ProbabilityTheory.condIndep_iff
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' m₁ m₂ mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
hm₁ : m₁ ≤ mΩ
hm₂ : m₂ ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ CondIndep m' m₁ m₂ hm' μ ↔
    ∀ (t1 t2 : Set Ω),
      MeasurableSet t1 →
        MeasurableSet t2 →
          μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']
state_after: Ω : Type u_1
ι : Type u_2
m' m₁ m₂ mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
hm₁ : m₁ ≤ mΩ
hm₂ : m₂ ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ (∀ (t1 t2 : Set Ω),
      t1 ∈ {s | MeasurableSet s} →
        t2 ∈ {s | MeasurableSet s} →
          μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']) ↔
    ∀ (t1 t2 : Set Ω),
      MeasurableSet t1 →
        MeasurableSet t2 →
          μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᶠ[ae μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']

case hs1
Ω : Type u_1
ι : Type u_2
m' m₁ m₂ mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
hm₁ : m₁ ≤ mΩ
hm₂ : m₂ ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ ∀ s ∈ {s | MeasurableSet s}, MeasurableSet s

case hs2
Ω : Type u_1
ι : Type u_2
m' m₁ m₂ mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
hm₁ : m₁ ≤ mΩ
hm₂ : m₂ ≤ mΩ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ ∀ s ∈ {s | MeasurableSet s}, MeasurableSet s
tactic: rw [condIndep_iff_condIndepSets, condIndepSets_iff]
Theorem: IsAlgClosed.exists_pow_nat_eq
File: Mathlib/FieldTheory/IsAlgClosed/Basic.lean

Proof steps:
state_before: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
⊢ ∃ z, z ^ n = x
state_after: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
⊢ ∃ z, z ^ n = x
tactic: have : degree (X ^ n - C x) ≠ 0 := by
    rw [degree_X_pow_sub_C hn x]
    exact ne_of_gt (WithBot.coe_lt_coe.2 hn)
state_before: k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
⊢ ∃ z, z ^ n = x
state_after: case intro
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : (X ^ n - C x).IsRoot z
⊢ ∃ z, z ^ n = x
tactic: obtain ⟨z, hz⟩ := exists_root (X ^ n - C x) this
state_before: case intro
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : (X ^ n - C x).IsRoot z
⊢ ∃ z, z ^ n = x
state_after: case h
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : (X ^ n - C x).IsRoot z
⊢ z ^ n = x
tactic: use z
state_before: case h
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : (X ^ n - C x).IsRoot z
⊢ z ^ n = x
state_after: case h
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : z ^ n - x = 0
⊢ z ^ n = x
tactic: simp only [eval_C, eval_X, eval_pow, eval_sub, IsRoot.def] at hz
state_before: case h
k : Type u
inst✝¹ : Field k
inst✝ : IsAlgClosed k
x : k
n : ℕ
hn : 0 < n
this : (X ^ n - C x).degree ≠ 0
z : k
hz : z ^ n - x = 0
⊢ z ^ n = x
state_after: no goals
tactic: exact sub_eq_zero.1 hz
Theorem: Set.ncard_add_ncard_compl
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
s : Set α
hs : autoParam s.Finite _auto✝
hsc : autoParam sᶜ.Finite _auto✝
⊢ s.ncard + sᶜ.ncard = Nat.card α
state_after: no goals
tactic: rw [← ncard_univ, ← ncard_union_eq (@disjoint_compl_right _ _ s) hs hsc, union_compl_self]
Theorem: map_comp_one
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : FunLike F M N
inst✝ : OneHomClass F M N
f : F
⊢ ⇑f ∘ 1 = 1
state_after: no goals
tactic: simp
Theorem: MvPolynomial.coeffs_one_of_nontrivial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ coeffs 1 = {1}
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ {1} ⊆ coeffs 1
tactic: apply Finset.Subset.antisymm coeffs_one
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ {1} ⊆ coeffs 1
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ ∃ a ∈ support 1, coeff a 1 = 1
tactic: simp only [coeffs, Finset.singleton_subset_iff, Finset.mem_image]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ ∃ a ∈ support 1, coeff a 1 = 1
state_after: no goals
tactic: exact ⟨0, by simp⟩
Theorem: Option.map_map₂_right_anticomm
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β' → γ
g : β → β'
f' : β → α → δ
g' : δ → γ
h_right_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
⊢ map₂ f a (Option.map g b) = Option.map g' (map₂ f' b a)
state_after: no goals
tactic: cases a <;> cases b <;> simp [h_right_anticomm]
Theorem: CategoryTheory.GradedObject.ι_mapBifunctorMapMap
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_7, u_1} C₁
inst✝³ : Category.{u_8, u_2} C₂
inst✝² : Category.{u_9, u_3} C₃
F : C₁ ⥤ C₂ ⥤ C₃
I : Type u_4
J : Type u_5
K : Type u_6
p : I × J → K
X₁ X₂ : GradedObject I C₁
f : X₁ ⟶ X₂
Y₁ Y₂ : GradedObject J C₂
g : Y₁ ⟶ Y₂
inst✝¹ : (((mapBifunctor F I J).obj X₁).obj Y₁).HasMap p
inst✝ : (((mapBifunctor F I J).obj X₂).obj Y₂).HasMap p
i : I
j : J
k : K
h : p (i, j) = k
⊢ ιMapBifunctorMapObj F p X₁ Y₁ i j k h ≫ mapBifunctorMapMap F p f g k =
    (F.map (f i)).app (Y₁ j) ≫ (F.obj (X₂ i)).map (g j) ≫ ιMapBifunctorMapObj F p X₂ Y₂ i j k h
state_after: no goals
tactic: simp [ιMapBifunctorMapObj, mapBifunctorMapMap]
Theorem: CompleteLattice.top_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊤
state_after: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ⊤ (ωSup c) = ωSup (c.map ⊤)
tactic: intro c
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ⊤ (ωSup c) = ωSup (c.map ⊤)
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ∀ (c_1 : β), ⊤ (ωSup c) ≤ c_1 ↔ ωSup (c.map ⊤) ≤ c_1
tactic: apply eq_of_forall_ge_iff
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ∀ (c_1 : β), ⊤ (ωSup c) ≤ c_1 ↔ ωSup (c.map ⊤) ≤ c_1
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
z : β
⊢ ⊤ (ωSup c) ≤ z ↔ ωSup (c.map ⊤) ≤ z
tactic: intro z
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
z : β
⊢ ⊤ (ωSup c) ≤ z ↔ ωSup (c.map ⊤) ≤ z
state_after: no goals
tactic: simp only [OrderHom.instTopOrderHom_top, OrderHom.const_coe_coe, Function.const, top_le_iff,
    ωSup_le_iff, Chain.map_coe, Function.comp, forall_const]
Theorem: CategoryTheory.Functor.LeftExtension.coconeAtFunctor_map_hom
File: Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.6279, u_1} C
inst✝¹ : Category.{?u.6283, u_2} D
inst✝ : Category.{?u.6287, u_3} H
L : C ⥤ D
F : C ⥤ H
E✝ : L.LeftExtension F
Y : D
E E' : L.LeftExtension F
φ : E ⟶ E'
G : CostructuredArrow L Y
⊢ ((fun E => E.coconeAt Y) E).ι.app G ≫ φ.right.app Y = ((fun E => E.coconeAt Y) E').ι.app G
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.6279, u_1} C
inst✝¹ : Category.{?u.6283, u_2} D
inst✝ : Category.{?u.6287, u_3} H
L : C ⥤ D
F : C ⥤ H
E✝ : L.LeftExtension F
Y : D
E E' : L.LeftExtension F
φ : E ⟶ E'
G : CostructuredArrow L Y
⊢ (E.hom.app G.left ≫ E.right.map G.hom) ≫ φ.right.app Y = E'.hom.app G.left ≫ E'.right.map G.hom
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.6279, u_1} C
inst✝¹ : Category.{?u.6283, u_2} D
inst✝ : Category.{?u.6287, u_3} H
L : C ⥤ D
F : C ⥤ H
E✝ : L.LeftExtension F
Y : D
E E' : L.LeftExtension F
φ : E ⟶ E'
G : CostructuredArrow L Y
⊢ (E.hom.app G.left ≫ E.right.map G.hom) ≫ φ.right.app Y = E'.hom.app G.left ≫ E'.right.map G.hom
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.6279, u_1} C
inst✝¹ : Category.{?u.6283, u_2} D
inst✝ : Category.{?u.6287, u_3} H
L : C ⥤ D
F : C ⥤ H
E✝ : L.LeftExtension F
Y : D
E E' : L.LeftExtension F
φ : E ⟶ E'
G : CostructuredArrow L Y
⊢ (E.hom.app G.left ≫ E.right.map G.hom) ≫ φ.right.app Y =
    (E.hom ≫ ((whiskeringLeft C D H).obj L).map φ.right).app G.left ≫ E'.right.map G.hom
tactic: rw [← StructuredArrow.w φ]
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.6279, u_1} C
inst✝¹ : Category.{?u.6283, u_2} D
inst✝ : Category.{?u.6287, u_3} H
L : C ⥤ D
F : C ⥤ H
E✝ : L.LeftExtension F
Y : D
E E' : L.LeftExtension F
φ : E ⟶ E'
G : CostructuredArrow L Y
⊢ (E.hom.app G.left ≫ E.right.map G.hom) ≫ φ.right.app Y =
    (E.hom ≫ ((whiskeringLeft C D H).obj L).map φ.right).app G.left ≫ E'.right.map G.hom
state_after: no goals
tactic: simp
Theorem: MeasureTheory.ProbabilityMeasure.prod_swap
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ (μ.prod ν).map ⋯ = ν.prod μ
state_after: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑(ν.prod μ)
tactic: apply Subtype.ext
state_before: case a
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : ProbabilityMeasure α
ν : ProbabilityMeasure β
⊢ ↑((μ.prod ν).map ⋯) = ↑(ν.prod μ)
state_after: no goals
tactic: simp [Measure.prod_swap]
Theorem: Fintype.prod_dite_eq
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝³ : Fintype ι
inst✝² : Fintype κ
inst✝¹ : CommMonoid α
inst✝ : DecidableEq ι
i : ι
f : (j : ι) → i = j → α
⊢ (∏ j : ι, if h : i = j then f j h else 1) = f i ⋯
state_after: no goals
tactic: rw [Finset.prod_dite_eq, if_pos (mem_univ _)]
Theorem: SimpleGraph.egirth_anti
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

Proof steps:
state_before: α : Type u_1
G✝ G H : SimpleGraph α
h : G ≤ H
a : α
w : G.Walk a a
hw : w.IsCycle
⊢ ↑(Walk.mapLe h w).length ≤ ↑w.length
state_after: no goals
tactic: simp
Theorem: ONote.scale_opowAux
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: e a0 a : ONote
inst✝² : e.NF
inst✝¹ : a0.NF
inst✝ : a.NF
m : ℕ
⊢ (e.opowAux a0 a 0 m).repr = ω ^ e.repr * (opowAux 0 a0 a 0 m).repr
state_after: no goals
tactic: cases m <;> simp [opowAux]
state_before: e a0 a : ONote
inst✝² : e.NF
inst✝¹ : a0.NF
inst✝ : a.NF
k m : ℕ
⊢ (e.opowAux a0 a (k + 1) m).repr = ω ^ e.repr * (opowAux 0 a0 a (k + 1) m).repr
state_after: case pos
e a0 a : ONote
inst✝² : e.NF
inst✝¹ : a0.NF
inst✝ : a.NF
k m : ℕ
h : m = 0
⊢ (e.opowAux a0 a (k + 1) m).repr = ω ^ e.repr * (opowAux 0 a0 a (k + 1) m).repr

case neg
e a0 a : ONote
inst✝² : e.NF
inst✝¹ : a0.NF
inst✝ : a.NF
k m : ℕ
h : ¬m = 0
⊢ (e.opowAux a0 a (k + 1) m).repr = ω ^ e.repr * (opowAux 0 a0 a (k + 1) m).repr
tactic: by_cases h : m = 0
Theorem: CategoryTheory.ShortComplex.quasiIso_iff_comp_left
File: Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean

Proof steps:
state_before: C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ : QuasiIso φ
⊢ QuasiIso (φ ≫ φ') ↔ QuasiIso φ'
state_after: case mp
C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ : QuasiIso φ
⊢ QuasiIso (φ ≫ φ') → QuasiIso φ'

case mpr
C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ : QuasiIso φ
⊢ QuasiIso φ' → QuasiIso (φ ≫ φ')
tactic: constructor
Theorem: MeasureTheory.Memℒp.re
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
hf : Memℒp f p μ
⊢ Memℒp (fun x => RCLike.re (f x)) p μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
hf : Memℒp f p μ
this : ∀ (x : α), ‖RCLike.re (f x)‖ ≤ 1 * ‖f x‖
⊢ Memℒp (fun x => RCLike.re (f x)) p μ
tactic: have : ∀ x, ‖RCLike.re (f x)‖ ≤ 1 * ‖f x‖ := by
    intro x
    rw [one_mul]
    exact RCLike.norm_re_le_norm (f x)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
hf : Memℒp f p μ
this : ∀ (x : α), ‖RCLike.re (f x)‖ ≤ 1 * ‖f x‖
⊢ Memℒp (fun x => RCLike.re (f x)) p μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
hf : Memℒp f p μ
this : ∀ (x : α), ‖RCLike.re (f x)‖ ≤ 1 * ‖f x‖
⊢ AEStronglyMeasurable (fun x => RCLike.re (f x)) μ
tactic: refine hf.of_le_mul ?_ (eventually_of_forall this)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
hf : Memℒp f p μ
this : ∀ (x : α), ‖RCLike.re (f x)‖ ≤ 1 * ‖f x‖
⊢ AEStronglyMeasurable (fun x => RCLike.re (f x)) μ
state_after: no goals
tactic: exact RCLike.continuous_re.comp_aestronglyMeasurable hf.1
Theorem: Finset.Ico_diff_Ico_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ Ico a b \ Ico c b = Ico a (min b c)
state_after: no goals
tactic: cases le_total b c with
  | inl h => rw [Ico_eq_empty_of_le h, sdiff_empty, min_eq_left h]
  | inr h =>
    ext x
    rw [mem_sdiff, mem_Ico, mem_Ico, mem_Ico, min_eq_right h, and_assoc, not_and', not_le]
    exact and_congr_right' ⟨fun hx => hx.2 hx.1, fun hx => ⟨hx.trans_le h, fun _ => hx⟩⟩
Theorem: measurableSet_range_inr
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : MeasurableSpace α
⊢ MeasurableSet (range Sum.inr)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : MeasurableSpace α
⊢ MeasurableSet (Sum.inr '' univ)
tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : MeasurableSpace α
⊢ MeasurableSet (Sum.inr '' univ)
state_after: no goals
tactic: exact MeasurableSet.univ.inr_image
Theorem: ProjectiveSpectrum.vanishingIdeal_union
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ vanishingIdeal (t ∪ t') = vanishingIdeal t ⊓ vanishingIdeal t'
state_after: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ (vanishingIdeal (t ∪ t')).toIdeal = (vanishingIdeal t ⊓ vanishingIdeal t').toIdeal
tactic: ext1
state_before: case h
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ (vanishingIdeal (t ∪ t')).toIdeal = (vanishingIdeal t ⊓ vanishingIdeal t').toIdeal
state_after: no goals
tactic: exact (gc_ideal 𝒜).u_inf
Theorem: PadicInt.norm_le_pow_iff_le_valuation
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ‖x‖ ≤ ↑p ^ (-↑n) ↔ ↑n ≤ x.valuation
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ x.valuation
tactic: rw [norm_eq_pow_val hx]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ x.valuation
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ ↑p ^ (-↑k) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ ↑k
tactic: lift x.valuation to ℕ using x.valuation_nonneg with k
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ ↑p ^ (-↑k) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ ↑k
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k
tactic: simp only [Int.ofNat_le, zpow_neg, zpow_natCast]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k
tactic: have aux : ∀ m : ℕ, 0 < (p : ℝ) ^ m := by
    intro m
    refine pow_pos ?_ m
    exact mod_cast hp.1.pos
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k
tactic: rw [inv_le_inv (aux _) (aux _)]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k
tactic: have : p ^ n ≤ p ^ k ↔ n ≤ k := (pow_right_strictMono hp.1.one_lt).le_iff_le
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ p ^ n ≤ p ^ k
tactic: rw [← this]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ p ^ n ≤ p ^ k
state_after: no goals
tactic: norm_cast
Theorem: Metric.Sigma.one_le_dist_of_ne
File: Mathlib/Topology/MetricSpace/Gluing.lean

Proof steps:
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i j : ι
h : i ≠ j
x : E i
y : E j
⊢ 1 ≤ dist ⟨i, x⟩ ⟨j, y⟩
state_after: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i j : ι
h : i ≠ j
x : E i
y : E j
⊢ 1 ≤ dist x ⋯.some + 1 + dist ⋯.some y
tactic: rw [Sigma.dist_ne h x y]
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
i j : ι
h : i ≠ j
x : E i
y : E j
⊢ 1 ≤ dist x ⋯.some + 1 + dist ⋯.some y
state_after: no goals
tactic: linarith [@dist_nonneg _ _ x (Nonempty.some ⟨x⟩), @dist_nonneg _ _ (Nonempty.some ⟨y⟩) y]
Theorem: Disjoint.symmDiff_eq_sup
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : Disjoint a b
⊢ a ∆ b = a ⊔ b
state_after: no goals
tactic: rw [symmDiff, h.sdiff_eq_left, h.sdiff_eq_right]