CryptographicEstimators Library

This is a sample reference manual for CryptographicEstimators library.

To use this module, you need to import it:

from cryptographic_estimators import *

This reference shows a minimal example of documentation of the CryptographicEstimators library following SageMath guidelines.

• base_constants
• base_estimator
  • BaseEstimator
    • BaseEstimator.algorithm_names()
    • BaseEstimator.algorithms()
    • BaseEstimator.bit_complexities
    • BaseEstimator.complexity_type
    • BaseEstimator.estimate()
    • BaseEstimator.estimator_type
    • BaseEstimator.excluded_algorithms_by_default
    • BaseEstimator.fastest_algorithm()
    • BaseEstimator.memory_access
    • BaseEstimator.nalgorithms()
    • BaseEstimator.reset()
    • BaseEstimator.table()
• estimation_renderer
  • EstimationRenderer
    • EstimationRenderer.as_table()
• base_problem
  • BaseProblem
    • BaseProblem.expected_number_solutions()
    • BaseProblem.get_parameters()
    • BaseProblem.to_bitcomplexity_memory()
    • BaseProblem.to_bitcomplexity_time()
• helper
  • ComplexityType
    • ComplexityType.ESTIMATE
    • ComplexityType.TILDEO
  • concat_all_tables()
  • concat_pretty_tables()
  • gf_order_to_characteristic()
  • gf_order_to_degree()
  • is_power_of_two()
  • is_prime_power()
  • ngates()
  • round_or_truncate()
• base_algorithm
  • BaseAlgorithm
    • BaseAlgorithm.attack_type
    • BaseAlgorithm.complexity_type
    • BaseAlgorithm.get_optimal_parameters_dict()
    • BaseAlgorithm.has_optimal_parameter()
    • BaseAlgorithm.memory_access
    • BaseAlgorithm.memory_access_cost()
    • BaseAlgorithm.memory_complexity()
    • BaseAlgorithm.optimal_parameters()
    • BaseAlgorithm.parameter_names()
    • BaseAlgorithm.parameter_ranges
    • BaseAlgorithm.reset()
    • BaseAlgorithm.set_parameter_ranges()
    • BaseAlgorithm.set_parameters()
    • BaseAlgorithm.time_complexity()
  • optimal_parameter()

UOVEstimator

• uov_estimator
  • UOVEstimator
    • UOVEstimator.algorithm_names()
    • UOVEstimator.algorithms()
    • UOVEstimator.bit_complexities
    • UOVEstimator.complexity_type
    • UOVEstimator.estimate()
    • UOVEstimator.estimator_type
    • UOVEstimator.excluded_algorithms_by_default
    • UOVEstimator.fastest_algorithm()
    • UOVEstimator.memory_access
    • UOVEstimator.nalgorithms()
    • UOVEstimator.reset()
    • UOVEstimator.table()
• uov_constants
• uov_problem
  • UOVProblem
    • UOVProblem.cost_one_hash
    • UOVProblem.expected_number_solutions()
    • UOVProblem.get_parameters()
    • UOVProblem.hashes_to_basic_operations()
    • UOVProblem.npolynomials()
    • UOVProblem.nvariables()
    • UOVProblem.order_of_the_field()
    • UOVProblem.theta
    • UOVProblem.to_bitcomplexity_memory()
    • UOVProblem.to_bitcomplexity_time()
• uov_algorithm
  • UOVAlgorithm
    • UOVAlgorithm.attack_type
    • UOVAlgorithm.complexity_type
    • UOVAlgorithm.get_optimal_parameters_dict()
    • UOVAlgorithm.has_optimal_parameter()
    • UOVAlgorithm.linear_algebra_constant()
    • UOVAlgorithm.memory_access
    • UOVAlgorithm.memory_access_cost()
    • UOVAlgorithm.memory_complexity()
    • UOVAlgorithm.optimal_parameters()
    • UOVAlgorithm.parameter_names()
    • UOVAlgorithm.parameter_ranges
    • UOVAlgorithm.reset()
    • UOVAlgorithm.set_parameter_ranges()
    • UOVAlgorithm.set_parameters()
    • UOVAlgorithm.time_complexity()

UOVAlgorithms

• direct_attack
  • DirectAttack
    • DirectAttack.attack_type
    • DirectAttack.complexity_type
    • DirectAttack.get_fastest_mq_algorithm()
    • DirectAttack.get_optimal_parameters_dict()
    • DirectAttack.has_optimal_parameter()
    • DirectAttack.linear_algebra_constant()
    • DirectAttack.memory_access
    • DirectAttack.memory_access_cost()
    • DirectAttack.memory_complexity()
    • DirectAttack.optimal_parameters()
    • DirectAttack.parameter_names()
    • DirectAttack.parameter_ranges
    • DirectAttack.reset()
    • DirectAttack.set_parameter_ranges()
    • DirectAttack.set_parameters()
    • DirectAttack.time_complexity()
• intersection_attack
  • IntersectionAttack
    • IntersectionAttack.attack_type
    • IntersectionAttack.complexity_type
    • IntersectionAttack.get_optimal_parameters_dict()
    • IntersectionAttack.has_optimal_parameter()
    • IntersectionAttack.k()
    • IntersectionAttack.linear_algebra_constant()
    • IntersectionAttack.memory_access
    • IntersectionAttack.memory_access_cost()
    • IntersectionAttack.memory_complexity()
    • IntersectionAttack.optimal_parameters()
    • IntersectionAttack.parameter_names()
    • IntersectionAttack.parameter_ranges
    • IntersectionAttack.reset()
    • IntersectionAttack.set_parameter_ranges()
    • IntersectionAttack.set_parameters()
    • IntersectionAttack.time_complexity()
• kipnis_shamir
  • KipnisShamir
    • KipnisShamir.attack_type
    • KipnisShamir.complexity_type
    • KipnisShamir.get_optimal_parameters_dict()
    • KipnisShamir.has_optimal_parameter()
    • KipnisShamir.linear_algebra_constant()
    • KipnisShamir.memory_access
    • KipnisShamir.memory_access_cost()
    • KipnisShamir.memory_complexity()
    • KipnisShamir.optimal_parameters()
    • KipnisShamir.parameter_names()
    • KipnisShamir.parameter_ranges
    • KipnisShamir.reset()
    • KipnisShamir.set_parameter_ranges()
    • KipnisShamir.set_parameters()
    • KipnisShamir.time_complexity()
• collision_attack
  • CollisionAttack
    • CollisionAttack.X()
    • CollisionAttack.Y()
    • CollisionAttack.attack_type
    • CollisionAttack.complexity_type
    • CollisionAttack.get_optimal_parameters_dict()
    • CollisionAttack.has_optimal_parameter()
    • CollisionAttack.linear_algebra_constant()
    • CollisionAttack.memory_access
    • CollisionAttack.memory_access_cost()
    • CollisionAttack.memory_complexity()
    • CollisionAttack.optimal_parameters()
    • CollisionAttack.parameter_names()
    • CollisionAttack.parameter_ranges
    • CollisionAttack.reset()
    • CollisionAttack.set_parameter_ranges()
    • CollisionAttack.set_parameters()
    • CollisionAttack.time_complexity()

BIKEEstimator

• bike_algorithm
  • BIKEAlgorithm
    • BIKEAlgorithm.attack_type
    • BIKEAlgorithm.complexity_type
    • BIKEAlgorithm.get_optimal_parameters_dict()
    • BIKEAlgorithm.has_optimal_parameter()
    • BIKEAlgorithm.memory_access
    • BIKEAlgorithm.memory_access_cost()
    • BIKEAlgorithm.memory_complexity()
    • BIKEAlgorithm.optimal_parameters()
    • BIKEAlgorithm.parameter_names()
    • BIKEAlgorithm.parameter_ranges
    • BIKEAlgorithm.reset()
    • BIKEAlgorithm.set_parameter_ranges()
    • BIKEAlgorithm.set_parameters()
    • BIKEAlgorithm.time_complexity()
• bike_estimator
  • BIKEEstimator
    • BIKEEstimator.algorithm_names()
    • BIKEEstimator.algorithms()
    • BIKEEstimator.bit_complexities
    • BIKEEstimator.complexity_type
    • BIKEEstimator.estimate()
    • BIKEEstimator.estimator_type
    • BIKEEstimator.excluded_algorithms_by_default
    • BIKEEstimator.fastest_algorithm()
    • BIKEEstimator.memory_access
    • BIKEEstimator.nalgorithms()
    • BIKEEstimator.reset()
    • BIKEEstimator.table()
• bike_constants
• bike_problem
  • BIKEProblem
    • BIKEProblem.expected_number_solutions()
    • BIKEProblem.get_parameters()
    • BIKEProblem.to_bitcomplexity_memory()
    • BIKEProblem.to_bitcomplexity_time()

BIKEAlgorithms

• sd_msg_attack
  • SDMsgAttack
    • SDMsgAttack.attack_type
    • SDMsgAttack.complexity_type
    • SDMsgAttack.get_fastest_sd_algorithm()
    • SDMsgAttack.get_optimal_parameters_dict()
    • SDMsgAttack.has_optimal_parameter()
    • SDMsgAttack.memory_access
    • SDMsgAttack.memory_access_cost()
    • SDMsgAttack.memory_complexity()
    • SDMsgAttack.optimal_parameters()
    • SDMsgAttack.parameter_names()
    • SDMsgAttack.parameter_ranges
    • SDMsgAttack.reset()
    • SDMsgAttack.set_parameter_ranges()
    • SDMsgAttack.set_parameters()
    • SDMsgAttack.time_complexity()
• sd_key_attack
  • SDKeyAttack
    • SDKeyAttack.attack_type
    • SDKeyAttack.complexity_type
    • SDKeyAttack.get_fastest_sd_algorithm()
    • SDKeyAttack.get_optimal_parameters_dict()
    • SDKeyAttack.has_optimal_parameter()
    • SDKeyAttack.memory_access
    • SDKeyAttack.memory_access_cost()
    • SDKeyAttack.memory_complexity()
    • SDKeyAttack.optimal_parameters()
    • SDKeyAttack.parameter_names()
    • SDKeyAttack.parameter_ranges
    • SDKeyAttack.reset()
    • SDKeyAttack.set_parameter_ranges()
    • SDKeyAttack.set_parameters()
    • SDKeyAttack.time_complexity()

RankSDEstimator

• ranksd_estimator
  • RankSDEstimator
    • RankSDEstimator.algorithm_names()
    • RankSDEstimator.algorithms()
    • RankSDEstimator.bit_complexities
    • RankSDEstimator.complexity_type
    • RankSDEstimator.estimate()
    • RankSDEstimator.estimator_type
    • RankSDEstimator.excluded_algorithms_by_default
    • RankSDEstimator.fastest_algorithm()
    • RankSDEstimator.memory_access
    • RankSDEstimator.nalgorithms()
    • RankSDEstimator.reset()
    • RankSDEstimator.table()
• ranksd_constants
• ranksd_problem
  • RankSDProblem
    • RankSDProblem.base_field_order()
    • RankSDProblem.code_dimension()
    • RankSDProblem.code_length()
    • RankSDProblem.degree_extension()
    • RankSDProblem.expected_number_solutions()
    • RankSDProblem.get_parameters()
    • RankSDProblem.set_operations_on_base_field()
    • RankSDProblem.target_rank()
    • RankSDProblem.theta
    • RankSDProblem.to_bitcomplexity_memory()
    • RankSDProblem.to_bitcomplexity_time()
• ranksd_algorithm
  • RankSDAlgorithm
    • RankSDAlgorithm.attack_type
    • RankSDAlgorithm.complexity_type
    • RankSDAlgorithm.compute_memory_complexity_helper()
    • RankSDAlgorithm.compute_time_complexity_helper()
    • RankSDAlgorithm.get_optimal_parameters_dict()
    • RankSDAlgorithm.get_reduced_instance_parameters()
    • RankSDAlgorithm.has_optimal_parameter()
    • RankSDAlgorithm.linear_algebra_constant()
    • RankSDAlgorithm.memory_access
    • RankSDAlgorithm.memory_access_cost()
    • RankSDAlgorithm.memory_complexity()
    • RankSDAlgorithm.optimal_parameters()
    • RankSDAlgorithm.parameter_names()
    • RankSDAlgorithm.parameter_ranges
    • RankSDAlgorithm.reset()
    • RankSDAlgorithm.set_parameter_ranges()
    • RankSDAlgorithm.set_parameters()
    • RankSDAlgorithm.time_complexity()
• ranksd_helper
  • compute_mb()
  • compute_nb()
  • find_b_sm_fqm()
  • find_best_choice_param_mm()
  • find_p_sm_fqm()
  • find_valid_choices_param_sm_fqm()
  • nb_fq_syz()
  • nb_fqm()

RankSDAlgorithms

• ourivski_johansson_2
  • OJ2
    • OJ2.attack_type
    • OJ2.complexity_type
    • OJ2.compute_memory_complexity_helper()
    • OJ2.compute_time_complexity_helper()
    • OJ2.get_optimal_parameters_dict()
    • OJ2.get_reduced_instance_parameters()
    • OJ2.has_optimal_parameter()
    • OJ2.linear_algebra_constant()
    • OJ2.memory_access
    • OJ2.memory_access_cost()
    • OJ2.memory_complexity()
    • OJ2.optimal_parameters()
    • OJ2.parameter_names()
    • OJ2.parameter_ranges
    • OJ2.reset()
    • OJ2.set_parameter_ranges()
    • OJ2.set_parameters()
    • OJ2.time_complexity()
• ourivski_johansson_1
  • OJ1
    • OJ1.attack_type
    • OJ1.complexity_type
    • OJ1.compute_memory_complexity_helper()
    • OJ1.compute_time_complexity_helper()
    • OJ1.get_optimal_parameters_dict()
    • OJ1.get_reduced_instance_parameters()
    • OJ1.has_optimal_parameter()
    • OJ1.linear_algebra_constant()
    • OJ1.memory_access
    • OJ1.memory_access_cost()
    • OJ1.memory_complexity()
    • OJ1.optimal_parameters()
    • OJ1.parameter_names()
    • OJ1.parameter_ranges
    • OJ1.reset()
    • OJ1.set_parameter_ranges()
    • OJ1.set_parameters()
    • OJ1.time_complexity()
• support_minors
  • SupportMinors
    • SupportMinors.a()
    • SupportMinors.attack_type
    • SupportMinors.b()
    • SupportMinors.complexity_type
    • SupportMinors.compute_memory_complexity_helper()
    • SupportMinors.compute_time_complexity_helper()
    • SupportMinors.get_optimal_parameters_dict()
    • SupportMinors.get_reduced_instance_parameters()
    • SupportMinors.has_optimal_parameter()
    • SupportMinors.linear_algebra_constant()
    • SupportMinors.memory_access
    • SupportMinors.memory_access_cost()
    • SupportMinors.memory_complexity()
    • SupportMinors.optimal_parameters()
    • SupportMinors.p()
    • SupportMinors.parameter_names()
    • SupportMinors.parameter_ranges
    • SupportMinors.reset()
    • SupportMinors.set_parameter_ranges()
    • SupportMinors.set_parameters()
    • SupportMinors.time_complexity()
• grs
  • GRS
    • GRS.attack_type
    • GRS.complexity_type
    • GRS.compute_memory_complexity_helper()
    • GRS.compute_time_complexity_helper()
    • GRS.get_optimal_parameters_dict()
    • GRS.get_reduced_instance_parameters()
    • GRS.has_optimal_parameter()
    • GRS.linear_algebra_constant()
    • GRS.memory_access
    • GRS.memory_access_cost()
    • GRS.memory_complexity()
    • GRS.optimal_parameters()
    • GRS.parameter_names()
    • GRS.parameter_ranges
    • GRS.reset()
    • GRS.set_parameter_ranges()
    • GRS.set_parameters()
    • GRS.time_complexity()
• guessing_enhanced_grs
  • GuessingEnhancedGRS
    • GuessingEnhancedGRS.attack_type
    • GuessingEnhancedGRS.complexity_type
    • GuessingEnhancedGRS.compute_memory_complexity_helper()
    • GuessingEnhancedGRS.compute_time_complexity_helper()
    • GuessingEnhancedGRS.get_optimal_parameters_dict()
    • GuessingEnhancedGRS.get_reduced_instance_parameters()
    • GuessingEnhancedGRS.has_optimal_parameter()
    • GuessingEnhancedGRS.linear_algebra_constant()
    • GuessingEnhancedGRS.memory_access
    • GuessingEnhancedGRS.memory_access_cost()
    • GuessingEnhancedGRS.memory_complexity()
    • GuessingEnhancedGRS.optimal_parameters()
    • GuessingEnhancedGRS.parameter_names()
    • GuessingEnhancedGRS.parameter_ranges
    • GuessingEnhancedGRS.reset()
    • GuessingEnhancedGRS.set_parameter_ranges()
    • GuessingEnhancedGRS.set_parameters()
    • GuessingEnhancedGRS.t()
    • GuessingEnhancedGRS.time_complexity()
• improved_grs
  • ImprovedGRS
    • ImprovedGRS.attack_type
    • ImprovedGRS.complexity_type
    • ImprovedGRS.compute_memory_complexity_helper()
    • ImprovedGRS.compute_time_complexity_helper()
    • ImprovedGRS.get_optimal_parameters_dict()
    • ImprovedGRS.get_reduced_instance_parameters()
    • ImprovedGRS.has_optimal_parameter()
    • ImprovedGRS.linear_algebra_constant()
    • ImprovedGRS.memory_access
    • ImprovedGRS.memory_access_cost()
    • ImprovedGRS.memory_complexity()
    • ImprovedGRS.optimal_parameters()
    • ImprovedGRS.parameter_names()
    • ImprovedGRS.parameter_ranges
    • ImprovedGRS.reset()
    • ImprovedGRS.set_parameter_ranges()
    • ImprovedGRS.set_parameters()
    • ImprovedGRS.time_complexity()
• hybrid_linearization
  • HybridLinearization
    • HybridLinearization.attack_type
    • HybridLinearization.complexity_type
    • HybridLinearization.compute_memory_complexity_helper()
    • HybridLinearization.compute_time_complexity_helper()
    • HybridLinearization.get_optimal_parameters_dict()
    • HybridLinearization.get_reduced_instance_parameters()
    • HybridLinearization.has_optimal_parameter()
    • HybridLinearization.linear_algebra_constant()
    • HybridLinearization.memory_access
    • HybridLinearization.memory_access_cost()
    • HybridLinearization.memory_complexity()
    • HybridLinearization.optimal_parameters()
    • HybridLinearization.parameter_names()
    • HybridLinearization.parameter_ranges
    • HybridLinearization.reset()
    • HybridLinearization.set_parameter_ranges()
    • HybridLinearization.set_parameters()
    • HybridLinearization.t()
    • HybridLinearization.time_complexity()
• max_minors
  • MaxMinors
    • MaxMinors.a()
    • MaxMinors.attack_type
    • MaxMinors.complexity_type
    • MaxMinors.compute_memory_complexity_helper()
    • MaxMinors.compute_time_complexity_helper()
    • MaxMinors.get_optimal_parameters_dict()
    • MaxMinors.get_reduced_instance_parameters()
    • MaxMinors.has_optimal_parameter()
    • MaxMinors.linear_algebra_constant()
    • MaxMinors.memory_access
    • MaxMinors.memory_access_cost()
    • MaxMinors.memory_complexity()
    • MaxMinors.optimal_parameters()
    • MaxMinors.p()
    • MaxMinors.parameter_names()
    • MaxMinors.parameter_ranges
    • MaxMinors.reset()
    • MaxMinors.set_parameter_ranges()
    • MaxMinors.set_parameters()
    • MaxMinors.time_complexity()
• basis_enumeration
  • BasisEnumeration
    • BasisEnumeration.attack_type
    • BasisEnumeration.complexity_type
    • BasisEnumeration.compute_memory_complexity_helper()
    • BasisEnumeration.compute_time_complexity_helper()
    • BasisEnumeration.get_optimal_parameters_dict()
    • BasisEnumeration.get_reduced_instance_parameters()
    • BasisEnumeration.has_optimal_parameter()
    • BasisEnumeration.linear_algebra_constant()
    • BasisEnumeration.memory_access
    • BasisEnumeration.memory_access_cost()
    • BasisEnumeration.memory_complexity()
    • BasisEnumeration.optimal_parameters()
    • BasisEnumeration.parameter_names()
    • BasisEnumeration.parameter_ranges
    • BasisEnumeration.reset()
    • BasisEnumeration.set_parameter_ranges()
    • BasisEnumeration.set_parameters()
    • BasisEnumeration.time_complexity()

LEEstimator

• le_estimator
  • LEEstimator
    • LEEstimator.algorithm_names()
    • LEEstimator.algorithms()
    • LEEstimator.bit_complexities
    • LEEstimator.complexity_type
    • LEEstimator.estimate()
    • LEEstimator.estimator_type
    • LEEstimator.excluded_algorithms_by_default
    • LEEstimator.fastest_algorithm()
    • LEEstimator.memory_access
    • LEEstimator.nalgorithms()
    • LEEstimator.reset()
    • LEEstimator.table()
• le_algorithm
  • LEAlgorithm
    • LEAlgorithm.attack_type
    • LEAlgorithm.complexity_type
    • LEAlgorithm.get_optimal_parameters_dict()
    • LEAlgorithm.has_optimal_parameter()
    • LEAlgorithm.memory_access
    • LEAlgorithm.memory_access_cost()
    • LEAlgorithm.memory_complexity()
    • LEAlgorithm.optimal_parameters()
    • LEAlgorithm.parameter_names()
    • LEAlgorithm.parameter_ranges
    • LEAlgorithm.reset()
    • LEAlgorithm.set_parameter_ranges()
    • LEAlgorithm.set_parameters()
    • LEAlgorithm.time_complexity()
• le_constants
  • VerboseInformation
    • VerboseInformation.ISD
    • VerboseInformation.LISTS
    • VerboseInformation.LISTS_SIZE
    • VerboseInformation.NORMAL_FORM
    • VerboseInformation.NW
• le_helper
  • cost_to_find_random_2dim_subcodes_with_support_w()
• le_problem
  • LEProblem
    • LEProblem.expected_number_solutions()
    • LEProblem.get_parameters()
    • LEProblem.to_bitcomplexity_memory()
    • LEProblem.to_bitcomplexity_time()

LEAlgorithms

• bbps
  • BBPS
    • BBPS.attack_type
    • BBPS.complexity_type
    • BBPS.get_optimal_parameters_dict()
    • BBPS.has_optimal_parameter()
    • BBPS.memory_access
    • BBPS.memory_access_cost()
    • BBPS.memory_complexity()
    • BBPS.optimal_parameters()
    • BBPS.parameter_names()
    • BBPS.parameter_ranges
    • BBPS.reset()
    • BBPS.set_parameter_ranges()
    • BBPS.set_parameters()
    • BBPS.time_complexity()
    • BBPS.w()
    • BBPS.w_prime()
• beullens
  • Beullens
    • Beullens.attack_type
    • Beullens.complexity_type
    • Beullens.get_optimal_parameters_dict()
    • Beullens.has_optimal_parameter()
    • Beullens.memory_access
    • Beullens.memory_access_cost()
    • Beullens.memory_complexity()
    • Beullens.optimal_parameters()
    • Beullens.parameter_names()
    • Beullens.parameter_ranges
    • Beullens.reset()
    • Beullens.set_parameter_ranges()
    • Beullens.set_parameters()
    • Beullens.time_complexity()
    • Beullens.w()
• leon
  • Leon
    • Leon.attack_type
    • Leon.complexity_type
    • Leon.get_optimal_parameters_dict()
    • Leon.has_optimal_parameter()
    • Leon.memory_access
    • Leon.memory_access_cost()
    • Leon.memory_complexity()
    • Leon.optimal_parameters()
    • Leon.parameter_names()
    • Leon.parameter_ranges
    • Leon.reset()
    • Leon.set_parameter_ranges()
    • Leon.set_parameters()
    • Leon.time_complexity()
    • Leon.w()

PKEstimator

• pk_algorithm
  • PKAlgorithm
    • PKAlgorithm.attack_type
    • PKAlgorithm.complexity_type
    • PKAlgorithm.get_optimal_parameters_dict()
    • PKAlgorithm.has_optimal_parameter()
    • PKAlgorithm.memory_access
    • PKAlgorithm.memory_access_cost()
    • PKAlgorithm.memory_complexity()
    • PKAlgorithm.optimal_parameters()
    • PKAlgorithm.parameter_names()
    • PKAlgorithm.parameter_ranges
    • PKAlgorithm.reset()
    • PKAlgorithm.set_parameter_ranges()
    • PKAlgorithm.set_parameters()
    • PKAlgorithm.time_complexity()
• pk_constants
  • VerboseInformation
    • VerboseInformation.KMP_FINAL_LIST
    • VerboseInformation.KMP_L1
    • VerboseInformation.KMP_L2
    • VerboseInformation.SBC_ISD
    • VerboseInformation.SBC_U
• pk_problem
  • PKProblem
    • PKProblem.expected_number_solutions()
    • PKProblem.get_parameters()
    • PKProblem.to_bitcomplexity_memory()
    • PKProblem.to_bitcomplexity_time()
• pk_helper
  • beullens_lee_brickell_adaptation()
  • cost_for_finding_subcode()
  • gauss_binomial()
  • lof()
• pk_estimator
  • PKEstimator
    • PKEstimator.algorithm_names()
    • PKEstimator.algorithms()
    • PKEstimator.bit_complexities
    • PKEstimator.complexity_type
    • PKEstimator.estimate()
    • PKEstimator.estimator_type
    • PKEstimator.excluded_algorithms_by_default
    • PKEstimator.fastest_algorithm()
    • PKEstimator.memory_access
    • PKEstimator.nalgorithms()
    • PKEstimator.reset()
    • PKEstimator.table()

PKAlgorithms

• kmp
  • KMP
    • KMP.attack_type
    • KMP.complexity_type
    • KMP.get_optimal_parameters_dict()
    • KMP.has_optimal_parameter()
    • KMP.memory_access
    • KMP.memory_access_cost()
    • KMP.memory_complexity()
    • KMP.optimal_parameters()
    • KMP.parameter_names()
    • KMP.parameter_ranges
    • KMP.reset()
    • KMP.set_parameter_ranges()
    • KMP.set_parameters()
    • KMP.time_complexity()
    • KMP.u()
• sbc
  • SBC
    • SBC.attack_type
    • SBC.complexity_type
    • SBC.d()
    • SBC.get_optimal_parameters_dict()
    • SBC.has_optimal_parameter()
    • SBC.memory_access
    • SBC.memory_access_cost()
    • SBC.memory_complexity()
    • SBC.optimal_parameters()
    • SBC.parameter_names()
    • SBC.parameter_ranges
    • SBC.reset()
    • SBC.set_parameter_ranges()
    • SBC.set_parameters()
    • SBC.time_complexity()
    • SBC.w()
    • SBC.w1()

RegSDEstimator

• regsd_helper
  • r_int()
• regsd_algorithm
  • RegSDAlgorithm
    • RegSDAlgorithm.attack_type
    • RegSDAlgorithm.complexity_type
    • RegSDAlgorithm.get_optimal_parameters_dict()
    • RegSDAlgorithm.has_optimal_parameter()
    • RegSDAlgorithm.memory_access
    • RegSDAlgorithm.memory_access_cost()
    • RegSDAlgorithm.memory_complexity()
    • RegSDAlgorithm.optimal_parameters()
    • RegSDAlgorithm.parameter_names()
    • RegSDAlgorithm.parameter_ranges
    • RegSDAlgorithm.reset()
    • RegSDAlgorithm.set_parameter_ranges()
    • RegSDAlgorithm.set_parameters()
    • RegSDAlgorithm.time_complexity()
• regsd_constants
• regsd_problem
  • RegSDProblem
    • RegSDProblem.expected_number_solutions()
    • RegSDProblem.get_parameters()
    • RegSDProblem.to_bitcomplexity_memory()
    • RegSDProblem.to_bitcomplexity_time()
• regsd_estimator
  • RegSDEstimator
    • RegSDEstimator.algorithm_names()
    • RegSDEstimator.algorithms()
    • RegSDEstimator.bit_complexities
    • RegSDEstimator.complexity_type
    • RegSDEstimator.estimate()
    • RegSDEstimator.estimator_type
    • RegSDEstimator.excluded_algorithms_by_default
    • RegSDEstimator.fastest_algorithm()
    • RegSDEstimator.memory_access
    • RegSDEstimator.nalgorithms()
    • RegSDEstimator.reset()
    • RegSDEstimator.table()

RegSDAlgorithms

• ccj
  • CCJ
    • CCJ.attack_type
    • CCJ.complexity_type
    • CCJ.ell()
    • CCJ.get_optimal_parameters_dict()
    • CCJ.has_optimal_parameter()
    • CCJ.memory_access
    • CCJ.memory_access_cost()
    • CCJ.memory_complexity()
    • CCJ.optimal_parameters()
    • CCJ.parameter_names()
    • CCJ.parameter_ranges
    • CCJ.reset()
    • CCJ.set_parameter_ranges()
    • CCJ.set_parameters()
    • CCJ.time_complexity()
• regisd_perm
  • RegularISDPerm
    • RegularISDPerm.attack_type
    • RegularISDPerm.complexity_type
    • RegularISDPerm.get_optimal_parameters_dict()
    • RegularISDPerm.has_optimal_parameter()
    • RegularISDPerm.memory_access
    • RegularISDPerm.memory_access_cost()
    • RegularISDPerm.memory_complexity()
    • RegularISDPerm.optimal_parameters()
    • RegularISDPerm.parameter_names()
    • RegularISDPerm.parameter_ranges
    • RegularISDPerm.reset()
    • RegularISDPerm.set_parameter_ranges()
    • RegularISDPerm.set_parameters()
    • RegularISDPerm.time_complexity()
• ccj_lin
  • CCJLin
    • CCJLin.attack_type
    • CCJLin.complexity_type
    • CCJLin.get_optimal_parameters_dict()
    • CCJLin.has_optimal_parameter()
    • CCJLin.memory_access
    • CCJLin.memory_access_cost()
    • CCJLin.memory_complexity()
    • CCJLin.optimal_parameters()
    • CCJLin.parameter_names()
    • CCJLin.parameter_ranges
    • CCJLin.reset()
    • CCJLin.set_parameter_ranges()
    • CCJLin.set_parameters()
    • CCJLin.time_complexity()
• regisd_rep
  • RegularISDRep
    • RegularISDRep.attack_type
    • RegularISDRep.complexity_type
    • RegularISDRep.ell()
    • RegularISDRep.eps_x()
    • RegularISDRep.eps_y()
    • RegularISDRep.get_optimal_parameters_dict()
    • RegularISDRep.has_optimal_parameter()
    • RegularISDRep.memory_access
    • RegularISDRep.memory_access_cost()
    • RegularISDRep.memory_complexity()
    • RegularISDRep.optimal_parameters()
    • RegularISDRep.p()
    • RegularISDRep.parameter_names()
    • RegularISDRep.parameter_ranges
    • RegularISDRep.reset()
    • RegularISDRep.set_parameter_ranges()
    • RegularISDRep.set_parameters()
    • RegularISDRep.time_complexity()
• regisd_enum
  • RegularISDEnum
    • RegularISDEnum.attack_type
    • RegularISDEnum.complexity_type
    • RegularISDEnum.ell()
    • RegularISDEnum.get_optimal_parameters_dict()
    • RegularISDEnum.has_optimal_parameter()
    • RegularISDEnum.memory_access
    • RegularISDEnum.memory_access_cost()
    • RegularISDEnum.memory_complexity()
    • RegularISDEnum.optimal_parameters()
    • RegularISDEnum.p()
    • RegularISDEnum.parameter_names()
    • RegularISDEnum.parameter_ranges
    • RegularISDEnum.reset()
    • RegularISDEnum.set_parameter_ranges()
    • RegularISDEnum.set_parameters()
    • RegularISDEnum.time_complexity()
• sd_attack
  • SDAttack
    • SDAttack.attack_type
    • SDAttack.complexity_type
    • SDAttack.get_optimal_parameters_dict()
    • SDAttack.has_optimal_parameter()
    • SDAttack.memory_access
    • SDAttack.memory_access_cost()
    • SDAttack.memory_complexity()
    • SDAttack.optimal_parameters()
    • SDAttack.parameter_names()
    • SDAttack.parameter_ranges
    • SDAttack.reset()
    • SDAttack.set_parameter_ranges()
    • SDAttack.set_parameters()
    • SDAttack.time_complexity()

PEEstimator

• pe_algorithm
  • PEAlgorithm
    • PEAlgorithm.attack_type
    • PEAlgorithm.complexity_type
    • PEAlgorithm.get_optimal_parameters_dict()
    • PEAlgorithm.has_optimal_parameter()
    • PEAlgorithm.memory_access
    • PEAlgorithm.memory_access_cost()
    • PEAlgorithm.memory_complexity()
    • PEAlgorithm.optimal_parameters()
    • PEAlgorithm.parameter_names()
    • PEAlgorithm.parameter_ranges
    • PEAlgorithm.reset()
    • PEAlgorithm.set_parameter_ranges()
    • PEAlgorithm.set_parameters()
    • PEAlgorithm.time_complexity()
• pe_constants
  • VerboseInformation
    • VerboseInformation.LISTS_SIZE
    • VerboseInformation.LIST_COMPUTATION
    • VerboseInformation.NORMAL_FORM
• pe_estimator
  • PEEstimator
    • PEEstimator.algorithm_names()
    • PEEstimator.algorithms()
    • PEEstimator.bit_complexities
    • PEEstimator.complexity_type
    • PEEstimator.estimate()
    • PEEstimator.estimator_type
    • PEEstimator.excluded_algorithms_by_default
    • PEEstimator.fastest_algorithm()
    • PEEstimator.memory_access
    • PEEstimator.nalgorithms()
    • PEEstimator.reset()
    • PEEstimator.table()
• pe_problem
  • PEProblem
    • PEProblem.expected_number_solutions()
    • PEProblem.get_parameters()
    • PEProblem.to_bitcomplexity_memory()
    • PEProblem.to_bitcomplexity_time()
• pe_helper
  • gv_distance()
  • hamming_ball()
  • median_size_of_random_orbit()
  • number_of_weight_d_codewords()
  • random_sparse_vec_orbit()

PEAlgorithms

• beullens
  • Beullens
    • Beullens.attack_type
    • Beullens.complexity_type
    • Beullens.get_optimal_parameters_dict()
    • Beullens.has_optimal_parameter()
    • Beullens.memory_access
    • Beullens.memory_access_cost()
    • Beullens.memory_complexity()
    • Beullens.optimal_parameters()
    • Beullens.parameter_names()
    • Beullens.parameter_ranges
    • Beullens.reset()
    • Beullens.set_parameter_ranges()
    • Beullens.set_parameters()
    • Beullens.time_complexity()
    • Beullens.w()
• leon
  • Leon
    • Leon.attack_type
    • Leon.complexity_type
    • Leon.get_optimal_parameters_dict()
    • Leon.has_optimal_parameter()
    • Leon.memory_access
    • Leon.memory_access_cost()
    • Leon.memory_complexity()
    • Leon.optimal_parameters()
    • Leon.parameter_names()
    • Leon.parameter_ranges
    • Leon.reset()
    • Leon.set_parameter_ranges()
    • Leon.set_parameters()
    • Leon.time_complexity()
    • Leon.w()
• ssa
  • SSA
    • SSA.attack_type
    • SSA.complexity_type
    • SSA.get_optimal_parameters_dict()
    • SSA.has_optimal_parameter()
    • SSA.memory_access
    • SSA.memory_access_cost()
    • SSA.memory_complexity()
    • SSA.optimal_parameters()
    • SSA.parameter_names()
    • SSA.parameter_ranges
    • SSA.reset()
    • SSA.set_parameter_ranges()
    • SSA.set_parameters()
    • SSA.time_complexity()

DummyEstimator

• dummy_algorithm
  • DummyAlgorithm
    • DummyAlgorithm.attack_type
    • DummyAlgorithm.complexity_type
    • DummyAlgorithm.get_optimal_parameters_dict()
    • DummyAlgorithm.has_optimal_parameter()
    • DummyAlgorithm.memory_access
    • DummyAlgorithm.memory_access_cost()
    • DummyAlgorithm.memory_complexity()
    • DummyAlgorithm.optimal_parameters()
    • DummyAlgorithm.parameter_names()
    • DummyAlgorithm.parameter_ranges
    • DummyAlgorithm.reset()
    • DummyAlgorithm.set_parameter_ranges()
    • DummyAlgorithm.set_parameters()
    • DummyAlgorithm.time_complexity()
• dummy_problem
  • DummyProblem
    • DummyProblem.expected_number_solutions()
    • DummyProblem.get_parameters()
    • DummyProblem.to_bitcomplexity_memory()
    • DummyProblem.to_bitcomplexity_time()
• dummy_estimator
  • DummyEstimator
    • DummyEstimator.algorithm_names()
    • DummyEstimator.algorithms()
    • DummyEstimator.bit_complexities
    • DummyEstimator.complexity_type
    • DummyEstimator.estimate()
    • DummyEstimator.estimator_type
    • DummyEstimator.excluded_algorithms_by_default
    • DummyEstimator.fastest_algorithm()
    • DummyEstimator.memory_access
    • DummyEstimator.nalgorithms()
    • DummyEstimator.reset()
    • DummyEstimator.table()

DummyAlgorithms

• dummy_algorithm1
  • DummyAlgorithm1
    • DummyAlgorithm1.attack_type
    • DummyAlgorithm1.complexity_type
    • DummyAlgorithm1.get_optimal_parameters_dict()
    • DummyAlgorithm1.has_optimal_parameter()
    • DummyAlgorithm1.memory_access
    • DummyAlgorithm1.memory_access_cost()
    • DummyAlgorithm1.memory_complexity()
    • DummyAlgorithm1.optimal_parameters()
    • DummyAlgorithm1.optimization_parameter_1()
    • DummyAlgorithm1.optimization_parameter_2()
    • DummyAlgorithm1.optimization_parameter_3()
    • DummyAlgorithm1.parameter_names()
    • DummyAlgorithm1.parameter_ranges
    • DummyAlgorithm1.reset()
    • DummyAlgorithm1.set_parameter_ranges()
    • DummyAlgorithm1.set_parameters()
    • DummyAlgorithm1.time_complexity()

MREstimator

• mr_estimator
  • MREstimator
    • MREstimator.algorithm_names()
    • MREstimator.algorithms()
    • MREstimator.bit_complexities
    • MREstimator.complexity_type
    • MREstimator.estimate()
    • MREstimator.estimator_type
    • MREstimator.excluded_algorithms_by_default
    • MREstimator.fastest_algorithm()
    • MREstimator.memory_access
    • MREstimator.nalgorithms()
    • MREstimator.reset()
    • MREstimator.table()
• mr_helper
  • Variant
    • Variant.block_wiedemann
    • Variant.strassen
  • determinant_of_A()
  • entry_i_j_of_A()
  • extended_binomial()
  • matrix_A()
  • minors_polynomial_degree()
  • minors_series()
• mr_algorithm
  • MRAlgorithm
    • MRAlgorithm.attack_type
    • MRAlgorithm.complexity_type
    • MRAlgorithm.cost_reduction()
    • MRAlgorithm.get_optimal_parameters_dict()
    • MRAlgorithm.get_problem_parameters_reduced()
    • MRAlgorithm.has_optimal_parameter()
    • MRAlgorithm.hybridization_factor()
    • MRAlgorithm.linear_algebra_constant()
    • MRAlgorithm.memory_access
    • MRAlgorithm.memory_access_cost()
    • MRAlgorithm.memory_complexity()
    • MRAlgorithm.optimal_parameters()
    • MRAlgorithm.parameter_names()
    • MRAlgorithm.parameter_ranges
    • MRAlgorithm.reset()
    • MRAlgorithm.set_parameter_ranges()
    • MRAlgorithm.set_parameters()
    • MRAlgorithm.time_complexity()
• mr_constants
• mr_problem
  • MRProblem
    • MRProblem.expected_number_solutions()
    • MRProblem.get_parameters()
    • MRProblem.length_solution_vector()
    • MRProblem.ncolumns()
    • MRProblem.nmatrices()
    • MRProblem.nrows()
    • MRProblem.order_of_the_field()
    • MRProblem.target_rank()
    • MRProblem.theta
    • MRProblem.to_bitcomplexity_memory()
    • MRProblem.to_bitcomplexity_time()

MRAlgorithms

• kernel_search
  • KernelSearch
    • KernelSearch.a()
    • KernelSearch.attack_type
    • KernelSearch.complexity_type
    • KernelSearch.cost_reduction()
    • KernelSearch.get_optimal_parameters_dict()
    • KernelSearch.get_problem_parameters_reduced()
    • KernelSearch.has_optimal_parameter()
    • KernelSearch.hybridization_factor()
    • KernelSearch.linear_algebra_constant()
    • KernelSearch.lv()
    • KernelSearch.memory_access
    • KernelSearch.memory_access_cost()
    • KernelSearch.memory_complexity()
    • KernelSearch.optimal_parameters()
    • KernelSearch.parameter_names()
    • KernelSearch.parameter_ranges
    • KernelSearch.reset()
    • KernelSearch.set_parameter_ranges()
    • KernelSearch.set_parameters()
    • KernelSearch.time_complexity()
• support_minors
  • SupportMinors
    • SupportMinors.a()
    • SupportMinors.attack_type
    • SupportMinors.b()
    • SupportMinors.complexity_type
    • SupportMinors.cost_reduction()
    • SupportMinors.get_optimal_parameters_dict()
    • SupportMinors.get_problem_parameters_reduced()
    • SupportMinors.has_optimal_parameter()
    • SupportMinors.hybridization_factor()
    • SupportMinors.linear_algebra_constant()
    • SupportMinors.lv()
    • SupportMinors.memory_access
    • SupportMinors.memory_access_cost()
    • SupportMinors.memory_complexity()
    • SupportMinors.nprime()
    • SupportMinors.optimal_parameters()
    • SupportMinors.parameter_names()
    • SupportMinors.parameter_ranges
    • SupportMinors.reset()
    • SupportMinors.set_parameter_ranges()
    • SupportMinors.set_parameters()
    • SupportMinors.time_complexity()
    • SupportMinors.variant()
• big_k
  • BigK
    • BigK.a()
    • BigK.attack_type
    • BigK.complexity_type
    • BigK.cost_reduction()
    • BigK.get_optimal_parameters_dict()
    • BigK.get_problem_parameters_reduced()
    • BigK.has_optimal_parameter()
    • BigK.hybridization_factor()
    • BigK.linear_algebra_constant()
    • BigK.lv()
    • BigK.memory_access
    • BigK.memory_access_cost()
    • BigK.memory_complexity()
    • BigK.optimal_parameters()
    • BigK.parameter_names()
    • BigK.parameter_ranges
    • BigK.reset()
    • BigK.set_parameter_ranges()
    • BigK.set_parameters()
    • BigK.time_complexity()
• minors
  • Minors
    • Minors.a()
    • Minors.attack_type
    • Minors.complexity_type
    • Minors.cost_reduction()
    • Minors.get_optimal_parameters_dict()
    • Minors.get_problem_parameters_reduced()
    • Minors.has_optimal_parameter()
    • Minors.hybridization_factor()
    • Minors.linear_algebra_constant()
    • Minors.lv()
    • Minors.memory_access
    • Minors.memory_access_cost()
    • Minors.memory_complexity()
    • Minors.optimal_parameters()
    • Minors.parameter_names()
    • Minors.parameter_ranges
    • Minors.reset()
    • Minors.set_parameter_ranges()
    • Minors.set_parameters()
    • Minors.time_complexity()
• bruteforce
  • BruteForce
    • BruteForce.a()
    • BruteForce.attack_type
    • BruteForce.complexity_type
    • BruteForce.cost_reduction()
    • BruteForce.get_optimal_parameters_dict()
    • BruteForce.get_problem_parameters_reduced()
    • BruteForce.has_optimal_parameter()
    • BruteForce.hybridization_factor()
    • BruteForce.linear_algebra_constant()
    • BruteForce.lv()
    • BruteForce.memory_access
    • BruteForce.memory_access_cost()
    • BruteForce.memory_complexity()
    • BruteForce.optimal_parameters()
    • BruteForce.parameter_names()
    • BruteForce.parameter_ranges
    • BruteForce.reset()
    • BruteForce.set_parameter_ranges()
    • BruteForce.set_parameters()
    • BruteForce.time_complexity()

SDFqEstimator

• sdfq_estimator
  • SDFqEstimator
    • SDFqEstimator.algorithm_names()
    • SDFqEstimator.algorithms()
    • SDFqEstimator.bit_complexities
    • SDFqEstimator.complexity_type
    • SDFqEstimator.estimate()
    • SDFqEstimator.estimator_type
    • SDFqEstimator.excluded_algorithms_by_default
    • SDFqEstimator.fastest_algorithm()
    • SDFqEstimator.memory_access
    • SDFqEstimator.nalgorithms()
    • SDFqEstimator.reset()
    • SDFqEstimator.table()
• sdfq_helper
  • binom()
  • min_max()
• sdfq_algorithm
  • SDFqAlgorithm
    • SDFqAlgorithm.attack_type
    • SDFqAlgorithm.complexity_type
    • SDFqAlgorithm.get_optimal_parameters_dict()
    • SDFqAlgorithm.has_optimal_parameter()
    • SDFqAlgorithm.memory_access
    • SDFqAlgorithm.memory_access_cost()
    • SDFqAlgorithm.memory_complexity()
    • SDFqAlgorithm.optimal_parameters()
    • SDFqAlgorithm.parameter_names()
    • SDFqAlgorithm.parameter_ranges
    • SDFqAlgorithm.reset()
    • SDFqAlgorithm.set_parameter_ranges()
    • SDFqAlgorithm.set_parameters()
    • SDFqAlgorithm.time_complexity()
• sdfq_problem
  • SDFqProblem
    • SDFqProblem.expected_number_solutions()
    • SDFqProblem.get_parameters()
    • SDFqProblem.to_bitcomplexity_memory()
    • SDFqProblem.to_bitcomplexity_time()
• sdfq_constants
  • VerboseInformation
    • VerboseInformation.CONSTRAINTS
    • VerboseInformation.GAUSS
    • VerboseInformation.LISTS
    • VerboseInformation.PERMUTATIONS
    • VerboseInformation.REPRESENTATIONS
    • VerboseInformation.TREE

SDFqAlgorithms

• leebrickell
  • LeeBrickell
    • LeeBrickell.attack_type
    • LeeBrickell.complexity_type
    • LeeBrickell.get_optimal_parameters_dict()
    • LeeBrickell.has_optimal_parameter()
    • LeeBrickell.memory_access
    • LeeBrickell.memory_access_cost()
    • LeeBrickell.memory_complexity()
    • LeeBrickell.optimal_parameters()
    • LeeBrickell.p()
    • LeeBrickell.parameter_names()
    • LeeBrickell.parameter_ranges
    • LeeBrickell.reset()
    • LeeBrickell.set_parameter_ranges()
    • LeeBrickell.set_parameters()
    • LeeBrickell.time_complexity()
• prange
  • Prange
    • Prange.attack_type
    • Prange.complexity_type
    • Prange.get_optimal_parameters_dict()
    • Prange.has_optimal_parameter()
    • Prange.memory_access
    • Prange.memory_access_cost()
    • Prange.memory_complexity()
    • Prange.optimal_parameters()
    • Prange.parameter_names()
    • Prange.parameter_ranges
    • Prange.reset()
    • Prange.set_parameter_ranges()
    • Prange.set_parameters()
    • Prange.time_complexity()
• stern
  • Stern
    • Stern.attack_type
    • Stern.complexity_type
    • Stern.get_optimal_parameters_dict()
    • Stern.has_optimal_parameter()
    • Stern.l()
    • Stern.memory_access
    • Stern.memory_access_cost()
    • Stern.memory_complexity()
    • Stern.optimal_parameters()
    • Stern.p()
    • Stern.parameter_names()
    • Stern.parameter_ranges
    • Stern.reset()
    • Stern.set_parameter_ranges()
    • Stern.set_parameters()
    • Stern.time_complexity()

SDEstimator

• sd_helper
  • binom()
  • min_max()
• sd_algorithm
  • SDAlgorithm
    • SDAlgorithm.attack_type
    • SDAlgorithm.complexity_type
    • SDAlgorithm.get_optimal_parameters_dict()
    • SDAlgorithm.has_optimal_parameter()
    • SDAlgorithm.memory_access
    • SDAlgorithm.memory_access_cost()
    • SDAlgorithm.memory_complexity()
    • SDAlgorithm.optimal_parameters()
    • SDAlgorithm.parameter_names()
    • SDAlgorithm.parameter_ranges
    • SDAlgorithm.r()
    • SDAlgorithm.reset()
    • SDAlgorithm.set_parameter_ranges()
    • SDAlgorithm.set_parameters()
    • SDAlgorithm.time_complexity()
• sd_estimator
  • SDEstimator
    • SDEstimator.algorithm_names()
    • SDEstimator.algorithms()
    • SDEstimator.bit_complexities
    • SDEstimator.complexity_type
    • SDEstimator.estimate()
    • SDEstimator.estimator_type
    • SDEstimator.excluded_algorithms_by_default
    • SDEstimator.fastest_algorithm()
    • SDEstimator.memory_access
    • SDEstimator.nalgorithms()
    • SDEstimator.reset()
    • SDEstimator.table()
• sd_constants
  • VerboseInformation
    • VerboseInformation.CONSTRAINTS
    • VerboseInformation.GAUSS
    • VerboseInformation.LISTS
    • VerboseInformation.PERMUTATIONS
    • VerboseInformation.REPRESENTATIONS
    • VerboseInformation.TREE
• sd_problem
  • SDProblem
    • SDProblem.expected_number_solutions()
    • SDProblem.get_parameters()
    • SDProblem.to_bitcomplexity_memory()
    • SDProblem.to_bitcomplexity_time()

SDAlgorithms

• bjmm_dw
  • BJMMdw
    • BJMMdw.attack_type
    • BJMMdw.complexity_type
    • BJMMdw.get_optimal_parameters_dict()
    • BJMMdw.has_optimal_parameter()
    • BJMMdw.initialize_parameter_ranges()
    • BJMMdw.memory_access
    • BJMMdw.memory_access_cost()
    • BJMMdw.memory_complexity()
    • BJMMdw.optimal_parameters()
    • BJMMdw.p()
    • BJMMdw.p1()
    • BJMMdw.parameter_names()
    • BJMMdw.parameter_ranges
    • BJMMdw.r()
    • BJMMdw.reset()
    • BJMMdw.set_parameter_ranges()
    • BJMMdw.set_parameters()
    • BJMMdw.time_complexity()
    • BJMMdw.w1()
    • BJMMdw.w11()
    • BJMMdw.w2()
• bjmm
  • BJMM
    • BJMM.attack_type
    • BJMM.complexity_type
    • BJMM.depth()
    • BJMM.get_optimal_parameters_dict()
    • BJMM.has_optimal_parameter()
    • BJMM.initialize_parameter_ranges()
    • BJMM.memory_access
    • BJMM.memory_access_cost()
    • BJMM.memory_complexity()
    • BJMM.optimal_parameters()
    • BJMM.parameter_names()
    • BJMM.parameter_ranges
    • BJMM.r()
    • BJMM.reset()
    • BJMM.set_parameter_ranges()
    • BJMM.set_parameters()
    • BJMM.time_complexity()
  • BJMMd2
    • BJMMd2.attack_type
    • BJMMd2.complexity_type
    • BJMMd2.get_optimal_parameters_dict()
    • BJMMd2.has_optimal_parameter()
    • BJMMd2.initialize_parameter_ranges()
    • BJMMd2.l()
    • BJMMd2.memory_access
    • BJMMd2.memory_access_cost()
    • BJMMd2.memory_complexity()
    • BJMMd2.optimal_parameters()
    • BJMMd2.p()
    • BJMMd2.p1()
    • BJMMd2.parameter_names()
    • BJMMd2.parameter_ranges
    • BJMMd2.r()
    • BJMMd2.reset()
    • BJMMd2.set_parameter_ranges()
    • BJMMd2.set_parameters()
    • BJMMd2.time_complexity()
  • BJMMd3
    • BJMMd3.attack_type
    • BJMMd3.complexity_type
    • BJMMd3.get_optimal_parameters_dict()
    • BJMMd3.has_optimal_parameter()
    • BJMMd3.initialize_parameter_ranges()
    • BJMMd3.l()
    • BJMMd3.memory_access
    • BJMMd3.memory_access_cost()
    • BJMMd3.memory_complexity()
    • BJMMd3.optimal_parameters()
    • BJMMd3.p()
    • BJMMd3.p1()
    • BJMMd3.p2()
    • BJMMd3.parameter_names()
    • BJMMd3.parameter_ranges
    • BJMMd3.r()
    • BJMMd3.reset()
    • BJMMd3.set_parameter_ranges()
    • BJMMd3.set_parameters()
    • BJMMd3.time_complexity()
• may_ozerov
  • MayOzerov
    • MayOzerov.attack_type
    • MayOzerov.complexity_type
    • MayOzerov.depth()
    • MayOzerov.get_optimal_parameters_dict()
    • MayOzerov.has_optimal_parameter()
    • MayOzerov.initialize_parameter_ranges()
    • MayOzerov.memory_access
    • MayOzerov.memory_access_cost()
    • MayOzerov.memory_complexity()
    • MayOzerov.optimal_parameters()
    • MayOzerov.parameter_names()
    • MayOzerov.parameter_ranges
    • MayOzerov.r()
    • MayOzerov.reset()
    • MayOzerov.set_parameter_ranges()
    • MayOzerov.set_parameters()
    • MayOzerov.time_complexity()
  • MayOzerovD2
    • MayOzerovD2.attack_type
    • MayOzerovD2.complexity_type
    • MayOzerovD2.get_optimal_parameters_dict()
    • MayOzerovD2.has_optimal_parameter()
    • MayOzerovD2.initialize_parameter_ranges()
    • MayOzerovD2.l()
    • MayOzerovD2.memory_access
    • MayOzerovD2.memory_access_cost()
    • MayOzerovD2.memory_complexity()
    • MayOzerovD2.optimal_parameters()
    • MayOzerovD2.p()
    • MayOzerovD2.p1()
    • MayOzerovD2.parameter_names()
    • MayOzerovD2.parameter_ranges
    • MayOzerovD2.r()
    • MayOzerovD2.reset()
    • MayOzerovD2.set_parameter_ranges()
    • MayOzerovD2.set_parameters()
    • MayOzerovD2.time_complexity()
  • MayOzerovD3
    • MayOzerovD3.attack_type
    • MayOzerovD3.complexity_type
    • MayOzerovD3.get_optimal_parameters_dict()
    • MayOzerovD3.has_optimal_parameter()
    • MayOzerovD3.initialize_parameter_ranges()
    • MayOzerovD3.l()
    • MayOzerovD3.memory_access
    • MayOzerovD3.memory_access_cost()
    • MayOzerovD3.memory_complexity()
    • MayOzerovD3.optimal_parameters()
    • MayOzerovD3.p()
    • MayOzerovD3.p1()
    • MayOzerovD3.p2()
    • MayOzerovD3.parameter_names()
    • MayOzerovD3.parameter_ranges
    • MayOzerovD3.r()
    • MayOzerovD3.reset()
    • MayOzerovD3.set_parameter_ranges()
    • MayOzerovD3.set_parameters()
    • MayOzerovD3.time_complexity()
• ball_collision
  • BallCollision
    • BallCollision.attack_type
    • BallCollision.complexity_type
    • BallCollision.get_optimal_parameters_dict()
    • BallCollision.has_optimal_parameter()
    • BallCollision.l()
    • BallCollision.memory_access
    • BallCollision.memory_access_cost()
    • BallCollision.memory_complexity()
    • BallCollision.optimal_parameters()
    • BallCollision.p()
    • BallCollision.parameter_names()
    • BallCollision.parameter_ranges
    • BallCollision.pl()
    • BallCollision.r()
    • BallCollision.reset()
    • BallCollision.set_parameter_ranges()
    • BallCollision.set_parameters()
    • BallCollision.time_complexity()
• prange
  • Prange
    • Prange.attack_type
    • Prange.complexity_type
    • Prange.get_optimal_parameters_dict()
    • Prange.has_optimal_parameter()
    • Prange.memory_access
    • Prange.memory_access_cost()
    • Prange.memory_complexity()
    • Prange.optimal_parameters()
    • Prange.parameter_names()
    • Prange.parameter_ranges
    • Prange.r()
    • Prange.reset()
    • Prange.set_parameter_ranges()
    • Prange.set_parameters()
    • Prange.time_complexity()
• bjmm_plus
  • BJMMplus
    • BJMMplus.attack_type
    • BJMMplus.complexity_type
    • BJMMplus.get_optimal_parameters_dict()
    • BJMMplus.has_optimal_parameter()
    • BJMMplus.initialize_parameter_ranges()
    • BJMMplus.l()
    • BJMMplus.l1()
    • BJMMplus.memory_access
    • BJMMplus.memory_access_cost()
    • BJMMplus.memory_complexity()
    • BJMMplus.optimal_parameters()
    • BJMMplus.p()
    • BJMMplus.p1()
    • BJMMplus.parameter_names()
    • BJMMplus.parameter_ranges
    • BJMMplus.r()
    • BJMMplus.reset()
    • BJMMplus.set_parameter_ranges()
    • BJMMplus.set_parameters()
    • BJMMplus.time_complexity()
• both_may
  • BothMay
    • BothMay.attack_type
    • BothMay.complexity_type
    • BothMay.get_optimal_parameters_dict()
    • BothMay.has_optimal_parameter()
    • BothMay.initialize_parameter_ranges()
    • BothMay.l()
    • BothMay.memory_access
    • BothMay.memory_access_cost()
    • BothMay.memory_complexity()
    • BothMay.optimal_parameters()
    • BothMay.p()
    • BothMay.p1()
    • BothMay.parameter_names()
    • BothMay.parameter_ranges
    • BothMay.r()
    • BothMay.reset()
    • BothMay.set_parameter_ranges()
    • BothMay.set_parameters()
    • BothMay.time_complexity()
    • BothMay.w1()
    • BothMay.w2()
• dumer
  • Dumer
    • Dumer.attack_type
    • Dumer.complexity_type
    • Dumer.get_optimal_parameters_dict()
    • Dumer.has_optimal_parameter()
    • Dumer.initialize_parameter_ranges()
    • Dumer.l()
    • Dumer.memory_access
    • Dumer.memory_access_cost()
    • Dumer.memory_complexity()
    • Dumer.optimal_parameters()
    • Dumer.p()
    • Dumer.parameter_names()
    • Dumer.parameter_ranges
    • Dumer.r()
    • Dumer.reset()
    • Dumer.set_parameter_ranges()
    • Dumer.set_parameters()
    • Dumer.time_complexity()
• stern
  • Stern
    • Stern.attack_type
    • Stern.complexity_type
    • Stern.get_optimal_parameters_dict()
    • Stern.has_optimal_parameter()
    • Stern.initialize_parameter_ranges()
    • Stern.l()
    • Stern.memory_access
    • Stern.memory_access_cost()
    • Stern.memory_complexity()
    • Stern.optimal_parameters()
    • Stern.p()
    • Stern.parameter_names()
    • Stern.parameter_ranges
    • Stern.r()
    • Stern.reset()
    • Stern.set_parameter_ranges()
    • Stern.set_parameters()
    • Stern.time_complexity()
• bjmm_pdw
  • BJMMpdw
    • BJMMpdw.attack_type
    • BJMMpdw.complexity_type
    • BJMMpdw.get_optimal_parameters_dict()
    • BJMMpdw.has_optimal_parameter()
    • BJMMpdw.initialize_parameter_ranges()
    • BJMMpdw.memory_access
    • BJMMpdw.memory_access_cost()
    • BJMMpdw.memory_complexity()
    • BJMMpdw.optimal_parameters()
    • BJMMpdw.p()
    • BJMMpdw.p1()
    • BJMMpdw.parameter_names()
    • BJMMpdw.parameter_ranges
    • BJMMpdw.r()
    • BJMMpdw.reset()
    • BJMMpdw.set_parameter_ranges()
    • BJMMpdw.set_parameters()
    • BJMMpdw.time_complexity()
    • BJMMpdw.w2()

SDWorkfactorModels

• bjmm
  • BJMMScipyModel
    • BJMMScipyModel.get_time_memory_and_parameters()
• workfactor_helper
  • binary_entropy()
  • binomial_approximation()
  • inverse_binary_entropy()
  • list_of_random_tuples()
  • may_ozerov_near_neighbor_time()
  • representations_asymptotic()
  • wrap()
• may_ozerov
  • MayOzerovScipyModel
    • MayOzerovScipyModel.get_time_memory_and_parameters()
• ball_collision
  • BallCollisionScipyModel
    • BallCollisionScipyModel.get_time_memory_and_parameters()
• prange
  • PrangeScipyModel
    • PrangeScipyModel.get_time_memory_and_parameters()
• both_may
  • BothMayScipyModel
    • BothMayScipyModel.get_time_memory_and_parameters()
• dumer
  • DumerScipyModel
    • DumerScipyModel.get_time_memory_and_parameters()
• stern
  • SternScipyModel
    • SternScipyModel.get_time_memory_and_parameters()

MQEstimator

• mq_estimator
  • MQEstimator
    • MQEstimator.algorithm_names()
    • MQEstimator.algorithms()
    • MQEstimator.bit_complexities
    • MQEstimator.complexity_type
    • MQEstimator.estimate()
    • MQEstimator.estimator_type
    • MQEstimator.excluded_algorithms_by_default
    • MQEstimator.fastest_algorithm()
    • MQEstimator.memory_access
    • MQEstimator.nalgorithms()
    • MQEstimator.reset()
    • MQEstimator.table()
• mq_problem
  • MQProblem
    • MQProblem.expected_number_solutions()
    • MQProblem.get_parameters()
    • MQProblem.get_problem_parameters()
    • MQProblem.is_defined_over_finite_field()
    • MQProblem.is_overdefined_system()
    • MQProblem.is_square_system()
    • MQProblem.is_underdefined_system()
    • MQProblem.npolynomials()
    • MQProblem.nvariables()
    • MQProblem.order_of_the_field()
    • MQProblem.theta
    • MQProblem.to_bitcomplexity_memory()
    • MQProblem.to_bitcomplexity_time()
• degree_of_regularity
  • generic_system()
  • quadratic_system()
  • regular_system()
  • semi_regular_system()
• mq_helper
  • nmonomials_of_degree()
  • nmonomials_up_to_degree()
  • sum_of_binomial_coefficients()
• mq_constants
• mq_algorithm
  • MQAlgorithm
    • MQAlgorithm.attack_type
    • MQAlgorithm.complexity_type
    • MQAlgorithm.get_optimal_parameters_dict()
    • MQAlgorithm.get_reduced_parameters()
    • MQAlgorithm.has_optimal_parameter()
    • MQAlgorithm.linear_algebra_constant()
    • MQAlgorithm.memory_access
    • MQAlgorithm.memory_access_cost()
    • MQAlgorithm.memory_complexity()
    • MQAlgorithm.npolynomials_reduced()
    • MQAlgorithm.nvariables_reduced()
    • MQAlgorithm.optimal_parameters()
    • MQAlgorithm.parameter_names()
    • MQAlgorithm.parameter_ranges
    • MQAlgorithm.reset()
    • MQAlgorithm.set_parameter_ranges()
    • MQAlgorithm.set_parameters()
    • MQAlgorithm.time_complexity()
• witness_degree
  • quadratic_system()
  • semi_regular_system()

series

• nmonomial
  • NMonomialSeries
    • NMonomialSeries.nmonomials_of_degree()
    • NMonomialSeries.nmonomials_up_to_degree()
• hilbert
  • HilbertSeries
    • HilbertSeries.coefficient_of_degree()
    • HilbertSeries.coefficient_up_to_degree()
    • HilbertSeries.degrees
    • HilbertSeries.first_nonpositive_coefficient()
    • HilbertSeries.first_nonpositive_coefficient_up_to_degree()
    • HilbertSeries.npolynomials
    • HilbertSeries.nvariables
    • HilbertSeries.precision

MQAlgorithms

• mht
  • MHT
    • MHT.attack_type
    • MHT.complexity_type
    • MHT.get_optimal_parameters_dict()
    • MHT.get_reduced_parameters()
    • MHT.has_optimal_parameter()
    • MHT.linear_algebra_constant()
    • MHT.memory_access
    • MHT.memory_access_cost()
    • MHT.memory_complexity()
    • MHT.npolynomials_reduced()
    • MHT.nvariables_reduced()
    • MHT.optimal_parameters()
    • MHT.parameter_names()
    • MHT.parameter_ranges
    • MHT.reset()
    • MHT.set_parameter_ranges()
    • MHT.set_parameters()
    • MHT.time_complexity()
• f5
  • F5
    • F5.attack_type
    • F5.complexity_type
    • F5.degree_of_polynomials()
    • F5.get_optimal_parameters_dict()
    • F5.get_reduced_parameters()
    • F5.has_optimal_parameter()
    • F5.linear_algebra_constant()
    • F5.memory_access
    • F5.memory_access_cost()
    • F5.memory_complexity()
    • F5.npolynomials_reduced()
    • F5.nvariables_reduced()
    • F5.optimal_parameters()
    • F5.parameter_names()
    • F5.parameter_ranges
    • F5.reset()
    • F5.set_parameter_ranges()
    • F5.set_parameters()
    • F5.time_complexity()
• dinur2
  • DinurSecond
    • DinurSecond.attack_type
    • DinurSecond.complexity_type
    • DinurSecond.get_optimal_parameters_dict()
    • DinurSecond.get_reduced_parameters()
    • DinurSecond.has_optimal_parameter()
    • DinurSecond.linear_algebra_constant()
    • DinurSecond.memory_access
    • DinurSecond.memory_access_cost()
    • DinurSecond.memory_complexity()
    • DinurSecond.n1()
    • DinurSecond.npolynomials_reduced()
    • DinurSecond.nvariables_reduced()
    • DinurSecond.optimal_parameters()
    • DinurSecond.parameter_names()
    • DinurSecond.parameter_ranges
    • DinurSecond.reset()
    • DinurSecond.set_parameter_ranges()
    • DinurSecond.set_parameters()
    • DinurSecond.time_complexity()
• cgmta
  • CGMTA
    • CGMTA.attack_type
    • CGMTA.complexity_type
    • CGMTA.get_optimal_parameters_dict()
    • CGMTA.get_reduced_parameters()
    • CGMTA.has_optimal_parameter()
    • CGMTA.linear_algebra_constant()
    • CGMTA.memory_access
    • CGMTA.memory_access_cost()
    • CGMTA.memory_complexity()
    • CGMTA.npolynomials_reduced()
    • CGMTA.nvariables_reduced()
    • CGMTA.optimal_parameters()
    • CGMTA.parameter_names()
    • CGMTA.parameter_ranges
    • CGMTA.reset()
    • CGMTA.set_parameter_ranges()
    • CGMTA.set_parameters()
    • CGMTA.time_complexity()
• kpg
  • KPG
    • KPG.attack_type
    • KPG.complexity_type
    • KPG.get_optimal_parameters_dict()
    • KPG.get_reduced_parameters()
    • KPG.has_optimal_parameter()
    • KPG.linear_algebra_constant()
    • KPG.memory_access
    • KPG.memory_access_cost()
    • KPG.memory_complexity()
    • KPG.npolynomials_reduced()
    • KPG.nvariables_reduced()
    • KPG.optimal_parameters()
    • KPG.parameter_names()
    • KPG.parameter_ranges
    • KPG.reset()
    • KPG.set_parameter_ranges()
    • KPG.set_parameters()
    • KPG.time_complexity()
• hashimoto
  • Hashimoto
    • Hashimoto.a()
    • Hashimoto.attack_type
    • Hashimoto.complexity_type
    • Hashimoto.get_optimal_parameters_dict()
    • Hashimoto.get_reduced_parameters()
    • Hashimoto.has_optimal_parameter()
    • Hashimoto.k()
    • Hashimoto.linear_algebra_constant()
    • Hashimoto.memory_access
    • Hashimoto.memory_access_cost()
    • Hashimoto.memory_complexity()
    • Hashimoto.npolynomials_reduced()
    • Hashimoto.nvariables_reduced()
    • Hashimoto.optimal_parameters()
    • Hashimoto.parameter_names()
    • Hashimoto.parameter_ranges
    • Hashimoto.reset()
    • Hashimoto.set_parameter_ranges()
    • Hashimoto.set_parameters()
    • Hashimoto.time_complexity()
• hybrid_f5
  • HybridF5
    • HybridF5.attack_type
    • HybridF5.complexity_type
    • HybridF5.degree_of_polynomials()
    • HybridF5.get_optimal_parameters_dict()
    • HybridF5.get_reduced_parameters()
    • HybridF5.has_optimal_parameter()
    • HybridF5.k()
    • HybridF5.linear_algebra_constant()
    • HybridF5.memory_access
    • HybridF5.memory_access_cost()
    • HybridF5.memory_complexity()
    • HybridF5.npolynomials_reduced()
    • HybridF5.nvariables_reduced()
    • HybridF5.optimal_parameters()
    • HybridF5.parameter_names()
    • HybridF5.parameter_ranges
    • HybridF5.reset()
    • HybridF5.set_parameter_ranges()
    • HybridF5.set_parameters()
    • HybridF5.time_complexity()
• lokshtanov
  • Lokshtanov
    • Lokshtanov.attack_type
    • Lokshtanov.complexity_type
    • Lokshtanov.delta()
    • Lokshtanov.get_optimal_parameters_dict()
    • Lokshtanov.get_reduced_parameters()
    • Lokshtanov.has_optimal_parameter()
    • Lokshtanov.linear_algebra_constant()
    • Lokshtanov.memory_access
    • Lokshtanov.memory_access_cost()
    • Lokshtanov.memory_complexity()
    • Lokshtanov.npolynomials_reduced()
    • Lokshtanov.nvariables_reduced()
    • Lokshtanov.optimal_parameters()
    • Lokshtanov.parameter_names()
    • Lokshtanov.parameter_ranges
    • Lokshtanov.reset()
    • Lokshtanov.set_parameter_ranges()
    • Lokshtanov.set_parameters()
    • Lokshtanov.time_complexity()
• exhaustive_search
  • ExhaustiveSearch
    • ExhaustiveSearch.attack_type
    • ExhaustiveSearch.complexity_type
    • ExhaustiveSearch.get_optimal_parameters_dict()
    • ExhaustiveSearch.get_reduced_parameters()
    • ExhaustiveSearch.has_optimal_parameter()
    • ExhaustiveSearch.linear_algebra_constant()
    • ExhaustiveSearch.memory_access
    • ExhaustiveSearch.memory_access_cost()
    • ExhaustiveSearch.memory_complexity()
    • ExhaustiveSearch.npolynomials_reduced()
    • ExhaustiveSearch.nvariables_reduced()
    • ExhaustiveSearch.optimal_parameters()
    • ExhaustiveSearch.parameter_names()
    • ExhaustiveSearch.parameter_ranges
    • ExhaustiveSearch.reset()
    • ExhaustiveSearch.set_parameter_ranges()
    • ExhaustiveSearch.set_parameters()
    • ExhaustiveSearch.time_complexity()
• booleansolve_fxl
  • BooleanSolveFXL
    • BooleanSolveFXL.attack_type
    • BooleanSolveFXL.complexity_type
    • BooleanSolveFXL.get_optimal_parameters_dict()
    • BooleanSolveFXL.get_reduced_parameters()
    • BooleanSolveFXL.has_optimal_parameter()
    • BooleanSolveFXL.k()
    • BooleanSolveFXL.linear_algebra_constant()
    • BooleanSolveFXL.memory_access
    • BooleanSolveFXL.memory_access_cost()
    • BooleanSolveFXL.memory_complexity()
    • BooleanSolveFXL.npolynomials_reduced()
    • BooleanSolveFXL.nvariables_reduced()
    • BooleanSolveFXL.optimal_parameters()
    • BooleanSolveFXL.parameter_names()
    • BooleanSolveFXL.parameter_ranges
    • BooleanSolveFXL.reset()
    • BooleanSolveFXL.set_parameter_ranges()
    • BooleanSolveFXL.set_parameters()
    • BooleanSolveFXL.time_complexity()
    • BooleanSolveFXL.variant()
• crossbred
  • Crossbred
    • Crossbred.D()
    • Crossbred.attack_type
    • Crossbred.complexity_type
    • Crossbred.d()
    • Crossbred.get_optimal_parameters_dict()
    • Crossbred.get_reduced_parameters()
    • Crossbred.has_optimal_parameter()
    • Crossbred.k()
    • Crossbred.linear_algebra_constant()
    • Crossbred.max_D
    • Crossbred.memory_access
    • Crossbred.memory_access_cost()
    • Crossbred.memory_complexity()
    • Crossbred.npolynomials_reduced()
    • Crossbred.nvariables_reduced()
    • Crossbred.optimal_parameters()
    • Crossbred.parameter_names()
    • Crossbred.parameter_ranges
    • Crossbred.reset()
    • Crossbred.set_parameter_ranges()
    • Crossbred.set_parameters()
    • Crossbred.time_complexity()
• bjorklund
  • Bjorklund
    • Bjorklund.attack_type
    • Bjorklund.complexity_type
    • Bjorklund.get_optimal_parameters_dict()
    • Bjorklund.get_reduced_parameters()
    • Bjorklund.has_optimal_parameter()
    • Bjorklund.lambda_()
    • Bjorklund.linear_algebra_constant()
    • Bjorklund.memory_access
    • Bjorklund.memory_access_cost()
    • Bjorklund.memory_complexity()
    • Bjorklund.npolynomials_reduced()
    • Bjorklund.nvariables_reduced()
    • Bjorklund.optimal_parameters()
    • Bjorklund.parameter_names()
    • Bjorklund.parameter_ranges
    • Bjorklund.reset()
    • Bjorklund.set_parameter_ranges()
    • Bjorklund.set_parameters()
    • Bjorklund.time_complexity()
• dinur1
  • DinurFirst
    • DinurFirst.attack_type
    • DinurFirst.complexity_type
    • DinurFirst.get_optimal_parameters_dict()
    • DinurFirst.get_reduced_parameters()
    • DinurFirst.has_optimal_parameter()
    • DinurFirst.kappa()
    • DinurFirst.lambda_()
    • DinurFirst.linear_algebra_constant()
    • DinurFirst.memory_access
    • DinurFirst.memory_access_cost()
    • DinurFirst.memory_complexity()
    • DinurFirst.npolynomials_reduced()
    • DinurFirst.nvariables_reduced()
    • DinurFirst.optimal_parameters()
    • DinurFirst.parameter_names()
    • DinurFirst.parameter_ranges
    • DinurFirst.reset()
    • DinurFirst.set_parameter_ranges()
    • DinurFirst.set_parameters()
    • DinurFirst.time_complexity()

MAYOEstimator

• mayo_estimator
  • MAYOEstimator
    • MAYOEstimator.algorithm_names()
    • MAYOEstimator.algorithms()
    • MAYOEstimator.bit_complexities
    • MAYOEstimator.complexity_type
    • MAYOEstimator.estimate()
    • MAYOEstimator.estimator_type
    • MAYOEstimator.excluded_algorithms_by_default
    • MAYOEstimator.fastest_algorithm()
    • MAYOEstimator.memory_access
    • MAYOEstimator.nalgorithms()
    • MAYOEstimator.reset()
    • MAYOEstimator.table()
• mayo_helper
• mayo_problem
  • MAYOProblem
    • MAYOProblem.cost_one_hash
    • MAYOProblem.expected_number_solutions()
    • MAYOProblem.get_parameters()
    • MAYOProblem.hashes_to_basic_operations()
    • MAYOProblem.npolynomials()
    • MAYOProblem.nvariables()
    • MAYOProblem.order_of_the_field()
    • MAYOProblem.order_oil_space()
    • MAYOProblem.theta
    • MAYOProblem.to_bitcomplexity_memory()
    • MAYOProblem.to_bitcomplexity_time()
    • MAYOProblem.whipping_parameter()
• mayo_algorithm
  • MAYOAlgorithm
    • MAYOAlgorithm.attack_type
    • MAYOAlgorithm.complexity_type
    • MAYOAlgorithm.get_optimal_parameters_dict()
    • MAYOAlgorithm.has_optimal_parameter()
    • MAYOAlgorithm.linear_algebra_constant()
    • MAYOAlgorithm.memory_access
    • MAYOAlgorithm.memory_access_cost()
    • MAYOAlgorithm.memory_complexity()
    • MAYOAlgorithm.optimal_parameters()
    • MAYOAlgorithm.parameter_names()
    • MAYOAlgorithm.parameter_ranges
    • MAYOAlgorithm.reset()
    • MAYOAlgorithm.set_parameter_ranges()
    • MAYOAlgorithm.set_parameters()
    • MAYOAlgorithm.time_complexity()
• mayo_constants

MAYOAlgorithms

• direct_attack
  • DirectAttack
    • DirectAttack.a()
    • DirectAttack.attack_type
    • DirectAttack.complexity_type
    • DirectAttack.get_optimal_parameters_dict()
    • DirectAttack.has_optimal_parameter()
    • DirectAttack.k()
    • DirectAttack.linear_algebra_constant()
    • DirectAttack.memory_access
    • DirectAttack.memory_access_cost()
    • DirectAttack.memory_complexity()
    • DirectAttack.optimal_parameters()
    • DirectAttack.parameter_names()
    • DirectAttack.parameter_ranges
    • DirectAttack.reset()
    • DirectAttack.set_parameter_ranges()
    • DirectAttack.set_parameters()
    • DirectAttack.time_complexity()
• intersection_attack
  • IntersectionAttack
    • IntersectionAttack.attack_type
    • IntersectionAttack.complexity_type
    • IntersectionAttack.get_optimal_parameters_dict()
    • IntersectionAttack.has_optimal_parameter()
    • IntersectionAttack.linear_algebra_constant()
    • IntersectionAttack.memory_access
    • IntersectionAttack.memory_access_cost()
    • IntersectionAttack.memory_complexity()
    • IntersectionAttack.optimal_parameters()
    • IntersectionAttack.parameter_names()
    • IntersectionAttack.parameter_ranges
    • IntersectionAttack.reset()
    • IntersectionAttack.set_parameter_ranges()
    • IntersectionAttack.set_parameters()
    • IntersectionAttack.time_complexity()
• claw_finding
  • ClawFinding
    • ClawFinding.X()
    • ClawFinding.Y()
    • ClawFinding.attack_type
    • ClawFinding.complexity_type
    • ClawFinding.get_optimal_parameters_dict()
    • ClawFinding.has_optimal_parameter()
    • ClawFinding.linear_algebra_constant()
    • ClawFinding.memory_access
    • ClawFinding.memory_access_cost()
    • ClawFinding.memory_complexity()
    • ClawFinding.optimal_parameters()
    • ClawFinding.parameter_names()
    • ClawFinding.parameter_ranges
    • ClawFinding.reset()
    • ClawFinding.set_parameter_ranges()
    • ClawFinding.set_parameters()
    • ClawFinding.time_complexity()
• kipnis_shamir
  • KipnisShamir
    • KipnisShamir.attack_type
    • KipnisShamir.complexity_type
    • KipnisShamir.get_optimal_parameters_dict()
    • KipnisShamir.has_optimal_parameter()
    • KipnisShamir.linear_algebra_constant()
    • KipnisShamir.memory_access
    • KipnisShamir.memory_access_cost()
    • KipnisShamir.memory_complexity()
    • KipnisShamir.optimal_parameters()
    • KipnisShamir.parameter_names()
    • KipnisShamir.parameter_ranges
    • KipnisShamir.reset()
    • KipnisShamir.set_parameter_ranges()
    • KipnisShamir.set_parameters()
    • KipnisShamir.time_complexity()
• reconciliation_attack
  • ReconciliationAttack
    • ReconciliationAttack.attack_type
    • ReconciliationAttack.complexity_type
    • ReconciliationAttack.get_optimal_parameters_dict()
    • ReconciliationAttack.has_optimal_parameter()
    • ReconciliationAttack.linear_algebra_constant()
    • ReconciliationAttack.memory_access
    • ReconciliationAttack.memory_access_cost()
    • ReconciliationAttack.memory_complexity()
    • ReconciliationAttack.optimal_parameters()
    • ReconciliationAttack.parameter_names()
    • ReconciliationAttack.parameter_ranges
    • ReconciliationAttack.reset()
    • ReconciliationAttack.set_parameter_ranges()
    • ReconciliationAttack.set_parameters()
    • ReconciliationAttack.time_complexity()

General Information

• Bibliographic References

Indices and Tables

• Index

• Module Index

• Search Page